var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all4) => {
  for (var name2 in all4)
    __defProp(target, name2, { get: all4[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key2 of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key2) && key2 !== except)
        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/is-buffer/index.js
var require_is_buffer = __commonJS({
  "node_modules/is-buffer/index.js"(exports, module2) {
    module2.exports = function isBuffer2(obj) {
      return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
    };
  }
});

// node_modules/extend/index.js
var require_extend = __commonJS({
  "node_modules/extend/index.js"(exports, module2) {
    "use strict";
    var hasOwn2 = Object.prototype.hasOwnProperty;
    var toStr = Object.prototype.toString;
    var defineProperty = Object.defineProperty;
    var gOPD = Object.getOwnPropertyDescriptor;
    var isArray3 = function isArray4(arr) {
      if (typeof Array.isArray === "function") {
        return Array.isArray(arr);
      }
      return toStr.call(arr) === "[object Array]";
    };
    var isPlainObject2 = function isPlainObject3(obj) {
      if (!obj || toStr.call(obj) !== "[object Object]") {
        return false;
      }
      var hasOwnConstructor = hasOwn2.call(obj, "constructor");
      var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn2.call(obj.constructor.prototype, "isPrototypeOf");
      if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
        return false;
      }
      var key2;
      for (key2 in obj) {
      }
      return typeof key2 === "undefined" || hasOwn2.call(obj, key2);
    };
    var setProperty = function setProperty2(target, options) {
      if (defineProperty && options.name === "__proto__") {
        defineProperty(target, options.name, {
          enumerable: true,
          configurable: true,
          value: options.newValue,
          writable: true
        });
      } else {
        target[options.name] = options.newValue;
      }
    };
    var getProperty = function getProperty2(obj, name2) {
      if (name2 === "__proto__") {
        if (!hasOwn2.call(obj, name2)) {
          return void 0;
        } else if (gOPD) {
          return gOPD(obj, name2).value;
        }
      }
      return obj[name2];
    };
    module2.exports = function extend4() {
      var options, name2, src, copy, copyIsArray, clone;
      var target = arguments[0];
      var i = 1;
      var length = arguments.length;
      var deep = false;
      if (typeof target === "boolean") {
        deep = target;
        target = arguments[1] || {};
        i = 2;
      }
      if (target == null || typeof target !== "object" && typeof target !== "function") {
        target = {};
      }
      for (; i < length; ++i) {
        options = arguments[i];
        if (options != null) {
          for (name2 in options) {
            src = getProperty(target, name2);
            copy = getProperty(options, name2);
            if (target !== copy) {
              if (deep && copy && (isPlainObject2(copy) || (copyIsArray = isArray3(copy)))) {
                if (copyIsArray) {
                  copyIsArray = false;
                  clone = src && isArray3(src) ? src : [];
                } else {
                  clone = src && isPlainObject2(src) ? src : {};
                }
                setProperty(target, { name: name2, newValue: extend4(deep, clone, copy) });
              } else if (typeof copy !== "undefined") {
                setProperty(target, { name: name2, newValue: copy });
              }
            }
          }
        }
      }
      return target;
    };
  }
});

// node_modules/acorn-jsx/xhtml.js
var require_xhtml = __commonJS({
  "node_modules/acorn-jsx/xhtml.js"(exports, module2) {
    module2.exports = {
      quot: '"',
      amp: "&",
      apos: "'",
      lt: "<",
      gt: ">",
      nbsp: "\xA0",
      iexcl: "\xA1",
      cent: "\xA2",
      pound: "\xA3",
      curren: "\xA4",
      yen: "\xA5",
      brvbar: "\xA6",
      sect: "\xA7",
      uml: "\xA8",
      copy: "\xA9",
      ordf: "\xAA",
      laquo: "\xAB",
      not: "\xAC",
      shy: "\xAD",
      reg: "\xAE",
      macr: "\xAF",
      deg: "\xB0",
      plusmn: "\xB1",
      sup2: "\xB2",
      sup3: "\xB3",
      acute: "\xB4",
      micro: "\xB5",
      para: "\xB6",
      middot: "\xB7",
      cedil: "\xB8",
      sup1: "\xB9",
      ordm: "\xBA",
      raquo: "\xBB",
      frac14: "\xBC",
      frac12: "\xBD",
      frac34: "\xBE",
      iquest: "\xBF",
      Agrave: "\xC0",
      Aacute: "\xC1",
      Acirc: "\xC2",
      Atilde: "\xC3",
      Auml: "\xC4",
      Aring: "\xC5",
      AElig: "\xC6",
      Ccedil: "\xC7",
      Egrave: "\xC8",
      Eacute: "\xC9",
      Ecirc: "\xCA",
      Euml: "\xCB",
      Igrave: "\xCC",
      Iacute: "\xCD",
      Icirc: "\xCE",
      Iuml: "\xCF",
      ETH: "\xD0",
      Ntilde: "\xD1",
      Ograve: "\xD2",
      Oacute: "\xD3",
      Ocirc: "\xD4",
      Otilde: "\xD5",
      Ouml: "\xD6",
      times: "\xD7",
      Oslash: "\xD8",
      Ugrave: "\xD9",
      Uacute: "\xDA",
      Ucirc: "\xDB",
      Uuml: "\xDC",
      Yacute: "\xDD",
      THORN: "\xDE",
      szlig: "\xDF",
      agrave: "\xE0",
      aacute: "\xE1",
      acirc: "\xE2",
      atilde: "\xE3",
      auml: "\xE4",
      aring: "\xE5",
      aelig: "\xE6",
      ccedil: "\xE7",
      egrave: "\xE8",
      eacute: "\xE9",
      ecirc: "\xEA",
      euml: "\xEB",
      igrave: "\xEC",
      iacute: "\xED",
      icirc: "\xEE",
      iuml: "\xEF",
      eth: "\xF0",
      ntilde: "\xF1",
      ograve: "\xF2",
      oacute: "\xF3",
      ocirc: "\xF4",
      otilde: "\xF5",
      ouml: "\xF6",
      divide: "\xF7",
      oslash: "\xF8",
      ugrave: "\xF9",
      uacute: "\xFA",
      ucirc: "\xFB",
      uuml: "\xFC",
      yacute: "\xFD",
      thorn: "\xFE",
      yuml: "\xFF",
      OElig: "\u0152",
      oelig: "\u0153",
      Scaron: "\u0160",
      scaron: "\u0161",
      Yuml: "\u0178",
      fnof: "\u0192",
      circ: "\u02C6",
      tilde: "\u02DC",
      Alpha: "\u0391",
      Beta: "\u0392",
      Gamma: "\u0393",
      Delta: "\u0394",
      Epsilon: "\u0395",
      Zeta: "\u0396",
      Eta: "\u0397",
      Theta: "\u0398",
      Iota: "\u0399",
      Kappa: "\u039A",
      Lambda: "\u039B",
      Mu: "\u039C",
      Nu: "\u039D",
      Xi: "\u039E",
      Omicron: "\u039F",
      Pi: "\u03A0",
      Rho: "\u03A1",
      Sigma: "\u03A3",
      Tau: "\u03A4",
      Upsilon: "\u03A5",
      Phi: "\u03A6",
      Chi: "\u03A7",
      Psi: "\u03A8",
      Omega: "\u03A9",
      alpha: "\u03B1",
      beta: "\u03B2",
      gamma: "\u03B3",
      delta: "\u03B4",
      epsilon: "\u03B5",
      zeta: "\u03B6",
      eta: "\u03B7",
      theta: "\u03B8",
      iota: "\u03B9",
      kappa: "\u03BA",
      lambda: "\u03BB",
      mu: "\u03BC",
      nu: "\u03BD",
      xi: "\u03BE",
      omicron: "\u03BF",
      pi: "\u03C0",
      rho: "\u03C1",
      sigmaf: "\u03C2",
      sigma: "\u03C3",
      tau: "\u03C4",
      upsilon: "\u03C5",
      phi: "\u03C6",
      chi: "\u03C7",
      psi: "\u03C8",
      omega: "\u03C9",
      thetasym: "\u03D1",
      upsih: "\u03D2",
      piv: "\u03D6",
      ensp: "\u2002",
      emsp: "\u2003",
      thinsp: "\u2009",
      zwnj: "\u200C",
      zwj: "\u200D",
      lrm: "\u200E",
      rlm: "\u200F",
      ndash: "\u2013",
      mdash: "\u2014",
      lsquo: "\u2018",
      rsquo: "\u2019",
      sbquo: "\u201A",
      ldquo: "\u201C",
      rdquo: "\u201D",
      bdquo: "\u201E",
      dagger: "\u2020",
      Dagger: "\u2021",
      bull: "\u2022",
      hellip: "\u2026",
      permil: "\u2030",
      prime: "\u2032",
      Prime: "\u2033",
      lsaquo: "\u2039",
      rsaquo: "\u203A",
      oline: "\u203E",
      frasl: "\u2044",
      euro: "\u20AC",
      image: "\u2111",
      weierp: "\u2118",
      real: "\u211C",
      trade: "\u2122",
      alefsym: "\u2135",
      larr: "\u2190",
      uarr: "\u2191",
      rarr: "\u2192",
      darr: "\u2193",
      harr: "\u2194",
      crarr: "\u21B5",
      lArr: "\u21D0",
      uArr: "\u21D1",
      rArr: "\u21D2",
      dArr: "\u21D3",
      hArr: "\u21D4",
      forall: "\u2200",
      part: "\u2202",
      exist: "\u2203",
      empty: "\u2205",
      nabla: "\u2207",
      isin: "\u2208",
      notin: "\u2209",
      ni: "\u220B",
      prod: "\u220F",
      sum: "\u2211",
      minus: "\u2212",
      lowast: "\u2217",
      radic: "\u221A",
      prop: "\u221D",
      infin: "\u221E",
      ang: "\u2220",
      and: "\u2227",
      or: "\u2228",
      cap: "\u2229",
      cup: "\u222A",
      "int": "\u222B",
      there4: "\u2234",
      sim: "\u223C",
      cong: "\u2245",
      asymp: "\u2248",
      ne: "\u2260",
      equiv: "\u2261",
      le: "\u2264",
      ge: "\u2265",
      sub: "\u2282",
      sup: "\u2283",
      nsub: "\u2284",
      sube: "\u2286",
      supe: "\u2287",
      oplus: "\u2295",
      otimes: "\u2297",
      perp: "\u22A5",
      sdot: "\u22C5",
      lceil: "\u2308",
      rceil: "\u2309",
      lfloor: "\u230A",
      rfloor: "\u230B",
      lang: "\u2329",
      rang: "\u232A",
      loz: "\u25CA",
      spades: "\u2660",
      clubs: "\u2663",
      hearts: "\u2665",
      diams: "\u2666"
    };
  }
});

// node_modules/acorn-jsx/node_modules/acorn/dist/acorn.mjs
var acorn_exports = {};
__export(acorn_exports, {
  Node: () => Node3,
  Parser: () => Parser3,
  Position: () => Position3,
  SourceLocation: () => SourceLocation3,
  TokContext: () => TokContext3,
  Token: () => Token3,
  TokenType: () => TokenType3,
  defaultOptions: () => defaultOptions2,
  getLineInfo: () => getLineInfo2,
  isIdentifierChar: () => isIdentifierChar2,
  isIdentifierStart: () => isIdentifierStart2,
  isNewLine: () => isNewLine2,
  keywordTypes: () => keywords$12,
  lineBreak: () => lineBreak2,
  lineBreakG: () => lineBreakG2,
  nonASCIIwhitespace: () => nonASCIIwhitespace2,
  parse: () => parse5,
  parseExpressionAt: () => parseExpressionAt3,
  tokContexts: () => types$12,
  tokTypes: () => types2,
  tokenizer: () => tokenizer3,
  version: () => version2
});
function isInAstralSet2(code2, set) {
  var pos2 = 65536;
  for (var i = 0; i < set.length; i += 2) {
    pos2 += set[i];
    if (pos2 > code2) {
      return false;
    }
    pos2 += set[i + 1];
    if (pos2 >= code2) {
      return true;
    }
  }
}
function isIdentifierStart2(code2, astral) {
  if (code2 < 65) {
    return code2 === 36;
  }
  if (code2 < 91) {
    return true;
  }
  if (code2 < 97) {
    return code2 === 95;
  }
  if (code2 < 123) {
    return true;
  }
  if (code2 <= 65535) {
    return code2 >= 170 && nonASCIIidentifierStart2.test(String.fromCharCode(code2));
  }
  if (astral === false) {
    return false;
  }
  return isInAstralSet2(code2, astralIdentifierStartCodes2);
}
function isIdentifierChar2(code2, astral) {
  if (code2 < 48) {
    return code2 === 36;
  }
  if (code2 < 58) {
    return true;
  }
  if (code2 < 65) {
    return false;
  }
  if (code2 < 91) {
    return true;
  }
  if (code2 < 97) {
    return code2 === 95;
  }
  if (code2 < 123) {
    return true;
  }
  if (code2 <= 65535) {
    return code2 >= 170 && nonASCIIidentifier2.test(String.fromCharCode(code2));
  }
  if (astral === false) {
    return false;
  }
  return isInAstralSet2(code2, astralIdentifierStartCodes2) || isInAstralSet2(code2, astralIdentifierCodes2);
}
function binop2(name2, prec) {
  return new TokenType3(name2, { beforeExpr: true, binop: prec });
}
function kw2(name2, options) {
  if (options === void 0)
    options = {};
  options.keyword = name2;
  return keywords$12[name2] = new TokenType3(name2, options);
}
function isNewLine2(code2, ecma2019String) {
  return code2 === 10 || code2 === 13 || !ecma2019String && (code2 === 8232 || code2 === 8233);
}
function has(obj, propName) {
  return hasOwnProperty2.call(obj, propName);
}
function wordsRegexp2(words) {
  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$");
}
function getLineInfo2(input, offset3) {
  for (var line2 = 1, cur = 0; ; ) {
    lineBreakG2.lastIndex = cur;
    var match = lineBreakG2.exec(input);
    if (match && match.index < offset3) {
      ++line2;
      cur = match.index + match[0].length;
    } else {
      return new Position3(line2, offset3 - cur);
    }
  }
}
function getOptions2(opts) {
  var options = {};
  for (var opt in defaultOptions2) {
    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions2[opt];
  }
  if (options.ecmaVersion >= 2015) {
    options.ecmaVersion -= 2009;
  }
  if (options.allowReserved == null) {
    options.allowReserved = options.ecmaVersion < 5;
  }
  if (isArray2(options.onToken)) {
    var tokens = options.onToken;
    options.onToken = function(token2) {
      return tokens.push(token2);
    };
  }
  if (isArray2(options.onComment)) {
    options.onComment = pushComment2(options, options.onComment);
  }
  return options;
}
function pushComment2(options, array) {
  return function(block, text5, start3, end, startLoc, endLoc) {
    var comment2 = {
      type: block ? "Block" : "Line",
      value: text5,
      start: start3,
      end
    };
    if (options.locations) {
      comment2.loc = new SourceLocation3(this, startLoc, endLoc);
    }
    if (options.ranges) {
      comment2.range = [start3, end];
    }
    array.push(comment2);
  };
}
function functionFlags2(async, generator) {
  return SCOPE_FUNCTION2 | (async ? SCOPE_ASYNC2 : 0) | (generator ? SCOPE_GENERATOR2 : 0);
}
function DestructuringErrors3() {
  this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = this.doubleProto = -1;
}
function finishNodeAt2(node2, type, pos2, loc) {
  node2.type = type;
  node2.end = pos2;
  if (this.options.locations) {
    node2.loc.end = loc;
  }
  if (this.options.ranges) {
    node2.range[1] = pos2;
  }
  return node2;
}
function buildUnicodeData2(ecmaVersion) {
  var d = data2[ecmaVersion] = {
    binary: wordsRegexp2(unicodeBinaryProperties2[ecmaVersion] + " " + unicodeGeneralCategoryValues2),
    nonBinary: {
      General_Category: wordsRegexp2(unicodeGeneralCategoryValues2),
      Script: wordsRegexp2(unicodeScriptValues2[ecmaVersion])
    }
  };
  d.nonBinary.Script_Extensions = d.nonBinary.Script;
  d.nonBinary.gc = d.nonBinary.General_Category;
  d.nonBinary.sc = d.nonBinary.Script;
  d.nonBinary.scx = d.nonBinary.Script_Extensions;
}
function codePointToString2(ch) {
  if (ch <= 65535) {
    return String.fromCharCode(ch);
  }
  ch -= 65536;
  return String.fromCharCode((ch >> 10) + 55296, (ch & 1023) + 56320);
}
function isSyntaxCharacter2(ch) {
  return ch === 36 || ch >= 40 && ch <= 43 || ch === 46 || ch === 63 || ch >= 91 && ch <= 94 || ch >= 123 && ch <= 125;
}
function isRegExpIdentifierStart2(ch) {
  return isIdentifierStart2(ch, true) || ch === 36 || ch === 95;
}
function isRegExpIdentifierPart2(ch) {
  return isIdentifierChar2(ch, true) || ch === 36 || ch === 95 || ch === 8204 || ch === 8205;
}
function isControlLetter2(ch) {
  return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122;
}
function isValidUnicode2(ch) {
  return ch >= 0 && ch <= 1114111;
}
function isCharacterClassEscape2(ch) {
  return ch === 100 || ch === 68 || ch === 115 || ch === 83 || ch === 119 || ch === 87;
}
function isUnicodePropertyNameCharacter2(ch) {
  return isControlLetter2(ch) || ch === 95;
}
function isUnicodePropertyValueCharacter2(ch) {
  return isUnicodePropertyNameCharacter2(ch) || isDecimalDigit2(ch);
}
function isDecimalDigit2(ch) {
  return ch >= 48 && ch <= 57;
}
function isHexDigit2(ch) {
  return ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102;
}
function hexToInt2(ch) {
  if (ch >= 65 && ch <= 70) {
    return 10 + (ch - 65);
  }
  if (ch >= 97 && ch <= 102) {
    return 10 + (ch - 97);
  }
  return ch - 48;
}
function isOctalDigit2(ch) {
  return ch >= 48 && ch <= 55;
}
function stringToNumber2(str, isLegacyOctalNumericLiteral) {
  if (isLegacyOctalNumericLiteral) {
    return parseInt(str, 8);
  }
  return parseFloat(str.replace(/_/g, ""));
}
function stringToBigInt2(str) {
  if (typeof BigInt !== "function") {
    return null;
  }
  return BigInt(str.replace(/_/g, ""));
}
function codePointToString$1(code2) {
  if (code2 <= 65535) {
    return String.fromCharCode(code2);
  }
  code2 -= 65536;
  return String.fromCharCode((code2 >> 10) + 55296, (code2 & 1023) + 56320);
}
function parse5(input, options) {
  return Parser3.parse(input, options);
}
function parseExpressionAt3(input, pos2, options) {
  return Parser3.parseExpressionAt(input, pos2, options);
}
function tokenizer3(input, options) {
  return Parser3.tokenizer(input, options);
}
var reservedWords2, ecma5AndLessKeywords2, keywords2, keywordRelationalOperator2, nonASCIIidentifierStartChars2, nonASCIIidentifierChars2, nonASCIIidentifierStart2, nonASCIIidentifier2, astralIdentifierStartCodes2, astralIdentifierCodes2, TokenType3, beforeExpr2, startsExpr2, keywords$12, types2, lineBreak2, lineBreakG2, nonASCIIwhitespace2, skipWhiteSpace2, ref2, hasOwnProperty2, toString2, isArray2, Position3, SourceLocation3, defaultOptions2, SCOPE_TOP2, SCOPE_FUNCTION2, SCOPE_VAR2, SCOPE_ASYNC2, SCOPE_GENERATOR2, SCOPE_ARROW2, SCOPE_SIMPLE_CATCH2, SCOPE_SUPER2, SCOPE_DIRECT_SUPER2, BIND_NONE2, BIND_VAR2, BIND_LEXICAL2, BIND_FUNCTION2, BIND_SIMPLE_CATCH2, BIND_OUTSIDE2, Parser3, prototypeAccessors2, pp2, literal2, pp$12, loopLabel2, switchLabel2, empty2, FUNC_STATEMENT2, FUNC_HANGING_STATEMENT2, FUNC_NULLABLE_ID2, pp$22, pp$32, empty$12, pp$42, pp$52, Scope3, Node3, pp$62, TokContext3, types$12, pp$72, ecma9BinaryProperties2, ecma10BinaryProperties2, ecma11BinaryProperties2, unicodeBinaryProperties2, unicodeGeneralCategoryValues2, ecma9ScriptValues2, ecma10ScriptValues2, ecma11ScriptValues2, unicodeScriptValues2, data2, pp$82, RegExpValidationState3, Token3, pp$92, INVALID_TEMPLATE_ESCAPE_ERROR2, version2;
var init_acorn = __esm({
  "node_modules/acorn-jsx/node_modules/acorn/dist/acorn.mjs"() {
    reservedWords2 = {
      3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
      5: "class enum extends super const export import",
      6: "enum",
      strict: "implements interface let package private protected public static yield",
      strictBind: "eval arguments"
    };
    ecma5AndLessKeywords2 = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
    keywords2 = {
      5: ecma5AndLessKeywords2,
      "5module": ecma5AndLessKeywords2 + " export import",
      6: ecma5AndLessKeywords2 + " const class extends export import super"
    };
    keywordRelationalOperator2 = /^in(stanceof)?$/;
    nonASCIIidentifierStartChars2 = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
    nonASCIIidentifierChars2 = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
    nonASCIIidentifierStart2 = new RegExp("[" + nonASCIIidentifierStartChars2 + "]");
    nonASCIIidentifier2 = new RegExp("[" + nonASCIIidentifierStartChars2 + nonASCIIidentifierChars2 + "]");
    nonASCIIidentifierStartChars2 = nonASCIIidentifierChars2 = null;
    astralIdentifierStartCodes2 = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
    astralIdentifierCodes2 = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
    TokenType3 = function TokenType4(label, conf) {
      if (conf === void 0)
        conf = {};
      this.label = label;
      this.keyword = conf.keyword;
      this.beforeExpr = !!conf.beforeExpr;
      this.startsExpr = !!conf.startsExpr;
      this.isLoop = !!conf.isLoop;
      this.isAssign = !!conf.isAssign;
      this.prefix = !!conf.prefix;
      this.postfix = !!conf.postfix;
      this.binop = conf.binop || null;
      this.updateContext = null;
    };
    beforeExpr2 = { beforeExpr: true };
    startsExpr2 = { startsExpr: true };
    keywords$12 = {};
    types2 = {
      num: new TokenType3("num", startsExpr2),
      regexp: new TokenType3("regexp", startsExpr2),
      string: new TokenType3("string", startsExpr2),
      name: new TokenType3("name", startsExpr2),
      eof: new TokenType3("eof"),
      // Punctuation token types.
      bracketL: new TokenType3("[", { beforeExpr: true, startsExpr: true }),
      bracketR: new TokenType3("]"),
      braceL: new TokenType3("{", { beforeExpr: true, startsExpr: true }),
      braceR: new TokenType3("}"),
      parenL: new TokenType3("(", { beforeExpr: true, startsExpr: true }),
      parenR: new TokenType3(")"),
      comma: new TokenType3(",", beforeExpr2),
      semi: new TokenType3(";", beforeExpr2),
      colon: new TokenType3(":", beforeExpr2),
      dot: new TokenType3("."),
      question: new TokenType3("?", beforeExpr2),
      questionDot: new TokenType3("?."),
      arrow: new TokenType3("=>", beforeExpr2),
      template: new TokenType3("template"),
      invalidTemplate: new TokenType3("invalidTemplate"),
      ellipsis: new TokenType3("...", beforeExpr2),
      backQuote: new TokenType3("`", startsExpr2),
      dollarBraceL: new TokenType3("${", { beforeExpr: true, startsExpr: true }),
      // Operators. These carry several kinds of properties to help the
      // parser use them properly (the presence of these properties is
      // what categorizes them as operators).
      //
      // `binop`, when present, specifies that this operator is a binary
      // operator, and will refer to its precedence.
      //
      // `prefix` and `postfix` mark the operator as a prefix or postfix
      // unary operator.
      //
      // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
      // binary operators with a very low precedence, that should result
      // in AssignmentExpression nodes.
      eq: new TokenType3("=", { beforeExpr: true, isAssign: true }),
      assign: new TokenType3("_=", { beforeExpr: true, isAssign: true }),
      incDec: new TokenType3("++/--", { prefix: true, postfix: true, startsExpr: true }),
      prefix: new TokenType3("!/~", { beforeExpr: true, prefix: true, startsExpr: true }),
      logicalOR: binop2("||", 1),
      logicalAND: binop2("&&", 2),
      bitwiseOR: binop2("|", 3),
      bitwiseXOR: binop2("^", 4),
      bitwiseAND: binop2("&", 5),
      equality: binop2("==/!=/===/!==", 6),
      relational: binop2("</>/<=/>=", 7),
      bitShift: binop2("<</>>/>>>", 8),
      plusMin: new TokenType3("+/-", { beforeExpr: true, binop: 9, prefix: true, startsExpr: true }),
      modulo: binop2("%", 10),
      star: binop2("*", 10),
      slash: binop2("/", 10),
      starstar: new TokenType3("**", { beforeExpr: true }),
      coalesce: binop2("??", 1),
      // Keyword token types.
      _break: kw2("break"),
      _case: kw2("case", beforeExpr2),
      _catch: kw2("catch"),
      _continue: kw2("continue"),
      _debugger: kw2("debugger"),
      _default: kw2("default", beforeExpr2),
      _do: kw2("do", { isLoop: true, beforeExpr: true }),
      _else: kw2("else", beforeExpr2),
      _finally: kw2("finally"),
      _for: kw2("for", { isLoop: true }),
      _function: kw2("function", startsExpr2),
      _if: kw2("if"),
      _return: kw2("return", beforeExpr2),
      _switch: kw2("switch"),
      _throw: kw2("throw", beforeExpr2),
      _try: kw2("try"),
      _var: kw2("var"),
      _const: kw2("const"),
      _while: kw2("while", { isLoop: true }),
      _with: kw2("with"),
      _new: kw2("new", { beforeExpr: true, startsExpr: true }),
      _this: kw2("this", startsExpr2),
      _super: kw2("super", startsExpr2),
      _class: kw2("class", startsExpr2),
      _extends: kw2("extends", beforeExpr2),
      _export: kw2("export"),
      _import: kw2("import", startsExpr2),
      _null: kw2("null", startsExpr2),
      _true: kw2("true", startsExpr2),
      _false: kw2("false", startsExpr2),
      _in: kw2("in", { beforeExpr: true, binop: 7 }),
      _instanceof: kw2("instanceof", { beforeExpr: true, binop: 7 }),
      _typeof: kw2("typeof", { beforeExpr: true, prefix: true, startsExpr: true }),
      _void: kw2("void", { beforeExpr: true, prefix: true, startsExpr: true }),
      _delete: kw2("delete", { beforeExpr: true, prefix: true, startsExpr: true })
    };
    lineBreak2 = /\r\n?|\n|\u2028|\u2029/;
    lineBreakG2 = new RegExp(lineBreak2.source, "g");
    nonASCIIwhitespace2 = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
    skipWhiteSpace2 = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
    ref2 = Object.prototype;
    hasOwnProperty2 = ref2.hasOwnProperty;
    toString2 = ref2.toString;
    isArray2 = Array.isArray || function(obj) {
      return toString2.call(obj) === "[object Array]";
    };
    Position3 = function Position4(line2, col) {
      this.line = line2;
      this.column = col;
    };
    Position3.prototype.offset = function offset2(n) {
      return new Position3(this.line, this.column + n);
    };
    SourceLocation3 = function SourceLocation4(p, start3, end) {
      this.start = start3;
      this.end = end;
      if (p.sourceFile !== null) {
        this.source = p.sourceFile;
      }
    };
    defaultOptions2 = {
      // `ecmaVersion` indicates the ECMAScript version to parse. Must be
      // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10
      // (2019). This influences support for strict mode, the set of
      // reserved words, and support for new syntax features. The default
      // is 10.
      ecmaVersion: 10,
      // `sourceType` indicates the mode the code should be parsed in.
      // Can be either `"script"` or `"module"`. This influences global
      // strict mode and parsing of `import` and `export` declarations.
      sourceType: "script",
      // `onInsertedSemicolon` can be a callback that will be called
      // when a semicolon is automatically inserted. It will be passed
      // the position of the comma as an offset, and if `locations` is
      // enabled, it is given the location as a `{line, column}` object
      // as second argument.
      onInsertedSemicolon: null,
      // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
      // trailing commas.
      onTrailingComma: null,
      // By default, reserved words are only enforced if ecmaVersion >= 5.
      // Set `allowReserved` to a boolean value to explicitly turn this on
      // an off. When this option has the value "never", reserved words
      // and keywords can also not be used as property names.
      allowReserved: null,
      // When enabled, a return at the top level is not considered an
      // error.
      allowReturnOutsideFunction: false,
      // When enabled, import/export statements are not constrained to
      // appearing at the top of the program.
      allowImportExportEverywhere: false,
      // When enabled, await identifiers are allowed to appear at the top-level scope,
      // but they are still not allowed in non-async functions.
      allowAwaitOutsideFunction: false,
      // When enabled, hashbang directive in the beginning of file
      // is allowed and treated as a line comment.
      allowHashBang: false,
      // When `locations` is on, `loc` properties holding objects with
      // `start` and `end` properties in `{line, column}` form (with
      // line being 1-based and column 0-based) will be attached to the
      // nodes.
      locations: false,
      // A function can be passed as `onToken` option, which will
      // cause Acorn to call that function with object in the same
      // format as tokens returned from `tokenizer().getToken()`. Note
      // that you are not allowed to call the parser from the
      // callback—that will corrupt its internal state.
      onToken: null,
      // A function can be passed as `onComment` option, which will
      // cause Acorn to call that function with `(block, text, start,
      // end)` parameters whenever a comment is skipped. `block` is a
      // boolean indicating whether this is a block (`/* */`) comment,
      // `text` is the content of the comment, and `start` and `end` are
      // character offsets that denote the start and end of the comment.
      // When the `locations` option is on, two more parameters are
      // passed, the full `{line, column}` locations of the start and
      // end of the comments. Note that you are not allowed to call the
      // parser from the callback—that will corrupt its internal state.
      onComment: null,
      // Nodes have their start and end characters offsets recorded in
      // `start` and `end` properties (directly on the node, rather than
      // the `loc` object, which holds line/column data. To also add a
      // [semi-standardized][range] `range` property holding a `[start,
      // end]` array with the same numbers, set the `ranges` option to
      // `true`.
      //
      // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
      ranges: false,
      // It is possible to parse multiple files into a single AST by
      // passing the tree produced by parsing the first file as
      // `program` option in subsequent parses. This will add the
      // toplevel forms of the parsed file to the `Program` (top) node
      // of an existing parse tree.
      program: null,
      // When `locations` is on, you can pass this to record the source
      // file in every node's `loc` object.
      sourceFile: null,
      // This value, if given, is stored in every node, whether
      // `locations` is on or off.
      directSourceFile: null,
      // When enabled, parenthesized expressions are represented by
      // (non-standard) ParenthesizedExpression nodes
      preserveParens: false
    };
    SCOPE_TOP2 = 1;
    SCOPE_FUNCTION2 = 2;
    SCOPE_VAR2 = SCOPE_TOP2 | SCOPE_FUNCTION2;
    SCOPE_ASYNC2 = 4;
    SCOPE_GENERATOR2 = 8;
    SCOPE_ARROW2 = 16;
    SCOPE_SIMPLE_CATCH2 = 32;
    SCOPE_SUPER2 = 64;
    SCOPE_DIRECT_SUPER2 = 128;
    BIND_NONE2 = 0;
    BIND_VAR2 = 1;
    BIND_LEXICAL2 = 2;
    BIND_FUNCTION2 = 3;
    BIND_SIMPLE_CATCH2 = 4;
    BIND_OUTSIDE2 = 5;
    Parser3 = function Parser4(options, input, startPos) {
      this.options = options = getOptions2(options);
      this.sourceFile = options.sourceFile;
      this.keywords = wordsRegexp2(keywords2[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
      var reserved = "";
      if (options.allowReserved !== true) {
        for (var v = options.ecmaVersion; ; v--) {
          if (reserved = reservedWords2[v]) {
            break;
          }
        }
        if (options.sourceType === "module") {
          reserved += " await";
        }
      }
      this.reservedWords = wordsRegexp2(reserved);
      var reservedStrict = (reserved ? reserved + " " : "") + reservedWords2.strict;
      this.reservedWordsStrict = wordsRegexp2(reservedStrict);
      this.reservedWordsStrictBind = wordsRegexp2(reservedStrict + " " + reservedWords2.strictBind);
      this.input = String(input);
      this.containsEsc = false;
      if (startPos) {
        this.pos = startPos;
        this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
        this.curLine = this.input.slice(0, this.lineStart).split(lineBreak2).length;
      } else {
        this.pos = this.lineStart = 0;
        this.curLine = 1;
      }
      this.type = types2.eof;
      this.value = null;
      this.start = this.end = this.pos;
      this.startLoc = this.endLoc = this.curPosition();
      this.lastTokEndLoc = this.lastTokStartLoc = null;
      this.lastTokStart = this.lastTokEnd = this.pos;
      this.context = this.initialContext();
      this.exprAllowed = true;
      this.inModule = options.sourceType === "module";
      this.strict = this.inModule || this.strictDirective(this.pos);
      this.potentialArrowAt = -1;
      this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
      this.labels = [];
      this.undefinedExports = {};
      if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!") {
        this.skipLineComment(2);
      }
      this.scopeStack = [];
      this.enterScope(SCOPE_TOP2);
      this.regexpState = null;
    };
    prototypeAccessors2 = { inFunction: { configurable: true }, inGenerator: { configurable: true }, inAsync: { configurable: true }, allowSuper: { configurable: true }, allowDirectSuper: { configurable: true }, treatFunctionsAsVar: { configurable: true } };
    Parser3.prototype.parse = function parse3() {
      var node2 = this.options.program || this.startNode();
      this.nextToken();
      return this.parseTopLevel(node2);
    };
    prototypeAccessors2.inFunction.get = function() {
      return (this.currentVarScope().flags & SCOPE_FUNCTION2) > 0;
    };
    prototypeAccessors2.inGenerator.get = function() {
      return (this.currentVarScope().flags & SCOPE_GENERATOR2) > 0;
    };
    prototypeAccessors2.inAsync.get = function() {
      return (this.currentVarScope().flags & SCOPE_ASYNC2) > 0;
    };
    prototypeAccessors2.allowSuper.get = function() {
      return (this.currentThisScope().flags & SCOPE_SUPER2) > 0;
    };
    prototypeAccessors2.allowDirectSuper.get = function() {
      return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER2) > 0;
    };
    prototypeAccessors2.treatFunctionsAsVar.get = function() {
      return this.treatFunctionsAsVarInScope(this.currentScope());
    };
    Parser3.prototype.inNonArrowFunction = function inNonArrowFunction() {
      return (this.currentThisScope().flags & SCOPE_FUNCTION2) > 0;
    };
    Parser3.extend = function extend3() {
      var plugins = [], len = arguments.length;
      while (len--)
        plugins[len] = arguments[len];
      var cls = this;
      for (var i = 0; i < plugins.length; i++) {
        cls = plugins[i](cls);
      }
      return cls;
    };
    Parser3.parse = function parse4(input, options) {
      return new this(options, input).parse();
    };
    Parser3.parseExpressionAt = function parseExpressionAt2(input, pos2, options) {
      var parser = new this(options, input, pos2);
      parser.nextToken();
      return parser.parseExpression();
    };
    Parser3.tokenizer = function tokenizer2(input, options) {
      return new this(options, input);
    };
    Object.defineProperties(Parser3.prototype, prototypeAccessors2);
    pp2 = Parser3.prototype;
    literal2 = /^(?:'((?:\\.|[^'\\])*?)'|"((?:\\.|[^"\\])*?)")/;
    pp2.strictDirective = function(start3) {
      for (; ; ) {
        skipWhiteSpace2.lastIndex = start3;
        start3 += skipWhiteSpace2.exec(this.input)[0].length;
        var match = literal2.exec(this.input.slice(start3));
        if (!match) {
          return false;
        }
        if ((match[1] || match[2]) === "use strict") {
          skipWhiteSpace2.lastIndex = start3 + match[0].length;
          var spaceAfter = skipWhiteSpace2.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;
          var next = this.input.charAt(end);
          return next === ";" || next === "}" || lineBreak2.test(spaceAfter[0]) && !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "=");
        }
        start3 += match[0].length;
        skipWhiteSpace2.lastIndex = start3;
        start3 += skipWhiteSpace2.exec(this.input)[0].length;
        if (this.input[start3] === ";") {
          start3++;
        }
      }
    };
    pp2.eat = function(type) {
      if (this.type === type) {
        this.next();
        return true;
      } else {
        return false;
      }
    };
    pp2.isContextual = function(name2) {
      return this.type === types2.name && this.value === name2 && !this.containsEsc;
    };
    pp2.eatContextual = function(name2) {
      if (!this.isContextual(name2)) {
        return false;
      }
      this.next();
      return true;
    };
    pp2.expectContextual = function(name2) {
      if (!this.eatContextual(name2)) {
        this.unexpected();
      }
    };
    pp2.canInsertSemicolon = function() {
      return this.type === types2.eof || this.type === types2.braceR || lineBreak2.test(this.input.slice(this.lastTokEnd, this.start));
    };
    pp2.insertSemicolon = function() {
      if (this.canInsertSemicolon()) {
        if (this.options.onInsertedSemicolon) {
          this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc);
        }
        return true;
      }
    };
    pp2.semicolon = function() {
      if (!this.eat(types2.semi) && !this.insertSemicolon()) {
        this.unexpected();
      }
    };
    pp2.afterTrailingComma = function(tokType, notNext) {
      if (this.type === tokType) {
        if (this.options.onTrailingComma) {
          this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
        }
        if (!notNext) {
          this.next();
        }
        return true;
      }
    };
    pp2.expect = function(type) {
      this.eat(type) || this.unexpected();
    };
    pp2.unexpected = function(pos2) {
      this.raise(pos2 != null ? pos2 : this.start, "Unexpected token");
    };
    pp2.checkPatternErrors = function(refDestructuringErrors, isAssign) {
      if (!refDestructuringErrors) {
        return;
      }
      if (refDestructuringErrors.trailingComma > -1) {
        this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element");
      }
      var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
      if (parens > -1) {
        this.raiseRecoverable(parens, "Parenthesized pattern");
      }
    };
    pp2.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
      if (!refDestructuringErrors) {
        return false;
      }
      var shorthandAssign = refDestructuringErrors.shorthandAssign;
      var doubleProto = refDestructuringErrors.doubleProto;
      if (!andThrow) {
        return shorthandAssign >= 0 || doubleProto >= 0;
      }
      if (shorthandAssign >= 0) {
        this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns");
      }
      if (doubleProto >= 0) {
        this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property");
      }
    };
    pp2.checkYieldAwaitInDefaultParams = function() {
      if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos)) {
        this.raise(this.yieldPos, "Yield expression cannot be a default value");
      }
      if (this.awaitPos) {
        this.raise(this.awaitPos, "Await expression cannot be a default value");
      }
    };
    pp2.isSimpleAssignTarget = function(expr) {
      if (expr.type === "ParenthesizedExpression") {
        return this.isSimpleAssignTarget(expr.expression);
      }
      return expr.type === "Identifier" || expr.type === "MemberExpression";
    };
    pp$12 = Parser3.prototype;
    pp$12.parseTopLevel = function(node2) {
      var exports = {};
      if (!node2.body) {
        node2.body = [];
      }
      while (this.type !== types2.eof) {
        var stmt = this.parseStatement(null, true, exports);
        node2.body.push(stmt);
      }
      if (this.inModule) {
        for (var i = 0, list3 = Object.keys(this.undefinedExports); i < list3.length; i += 1) {
          var name2 = list3[i];
          this.raiseRecoverable(this.undefinedExports[name2].start, "Export '" + name2 + "' is not defined");
        }
      }
      this.adaptDirectivePrologue(node2.body);
      this.next();
      node2.sourceType = this.options.sourceType;
      return this.finishNode(node2, "Program");
    };
    loopLabel2 = { kind: "loop" };
    switchLabel2 = { kind: "switch" };
    pp$12.isLet = function(context) {
      if (this.options.ecmaVersion < 6 || !this.isContextual("let")) {
        return false;
      }
      skipWhiteSpace2.lastIndex = this.pos;
      var skip = skipWhiteSpace2.exec(this.input);
      var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
      if (nextCh === 91) {
        return true;
      }
      if (context) {
        return false;
      }
      if (nextCh === 123) {
        return true;
      }
      if (isIdentifierStart2(nextCh, true)) {
        var pos2 = next + 1;
        while (isIdentifierChar2(this.input.charCodeAt(pos2), true)) {
          ++pos2;
        }
        var ident = this.input.slice(next, pos2);
        if (!keywordRelationalOperator2.test(ident)) {
          return true;
        }
      }
      return false;
    };
    pp$12.isAsyncFunction = function() {
      if (this.options.ecmaVersion < 8 || !this.isContextual("async")) {
        return false;
      }
      skipWhiteSpace2.lastIndex = this.pos;
      var skip = skipWhiteSpace2.exec(this.input);
      var next = this.pos + skip[0].length;
      return !lineBreak2.test(this.input.slice(this.pos, next)) && this.input.slice(next, next + 8) === "function" && (next + 8 === this.input.length || !isIdentifierChar2(this.input.charAt(next + 8)));
    };
    pp$12.parseStatement = function(context, topLevel, exports) {
      var starttype = this.type, node2 = this.startNode(), kind;
      if (this.isLet(context)) {
        starttype = types2._var;
        kind = "let";
      }
      switch (starttype) {
        case types2._break:
        case types2._continue:
          return this.parseBreakContinueStatement(node2, starttype.keyword);
        case types2._debugger:
          return this.parseDebuggerStatement(node2);
        case types2._do:
          return this.parseDoStatement(node2);
        case types2._for:
          return this.parseForStatement(node2);
        case types2._function:
          if (context && (this.strict || context !== "if" && context !== "label") && this.options.ecmaVersion >= 6) {
            this.unexpected();
          }
          return this.parseFunctionStatement(node2, false, !context);
        case types2._class:
          if (context) {
            this.unexpected();
          }
          return this.parseClass(node2, true);
        case types2._if:
          return this.parseIfStatement(node2);
        case types2._return:
          return this.parseReturnStatement(node2);
        case types2._switch:
          return this.parseSwitchStatement(node2);
        case types2._throw:
          return this.parseThrowStatement(node2);
        case types2._try:
          return this.parseTryStatement(node2);
        case types2._const:
        case types2._var:
          kind = kind || this.value;
          if (context && kind !== "var") {
            this.unexpected();
          }
          return this.parseVarStatement(node2, kind);
        case types2._while:
          return this.parseWhileStatement(node2);
        case types2._with:
          return this.parseWithStatement(node2);
        case types2.braceL:
          return this.parseBlock(true, node2);
        case types2.semi:
          return this.parseEmptyStatement(node2);
        case types2._export:
        case types2._import:
          if (this.options.ecmaVersion > 10 && starttype === types2._import) {
            skipWhiteSpace2.lastIndex = this.pos;
            var skip = skipWhiteSpace2.exec(this.input);
            var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
            if (nextCh === 40 || nextCh === 46) {
              return this.parseExpressionStatement(node2, this.parseExpression());
            }
          }
          if (!this.options.allowImportExportEverywhere) {
            if (!topLevel) {
              this.raise(this.start, "'import' and 'export' may only appear at the top level");
            }
            if (!this.inModule) {
              this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
            }
          }
          return starttype === types2._import ? this.parseImport(node2) : this.parseExport(node2, exports);
        default:
          if (this.isAsyncFunction()) {
            if (context) {
              this.unexpected();
            }
            this.next();
            return this.parseFunctionStatement(node2, true, !context);
          }
          var maybeName = this.value, expr = this.parseExpression();
          if (starttype === types2.name && expr.type === "Identifier" && this.eat(types2.colon)) {
            return this.parseLabeledStatement(node2, maybeName, expr, context);
          } else {
            return this.parseExpressionStatement(node2, expr);
          }
      }
    };
    pp$12.parseBreakContinueStatement = function(node2, keyword) {
      var isBreak = keyword === "break";
      this.next();
      if (this.eat(types2.semi) || this.insertSemicolon()) {
        node2.label = null;
      } else if (this.type !== types2.name) {
        this.unexpected();
      } else {
        node2.label = this.parseIdent();
        this.semicolon();
      }
      var i = 0;
      for (; i < this.labels.length; ++i) {
        var lab = this.labels[i];
        if (node2.label == null || lab.name === node2.label.name) {
          if (lab.kind != null && (isBreak || lab.kind === "loop")) {
            break;
          }
          if (node2.label && isBreak) {
            break;
          }
        }
      }
      if (i === this.labels.length) {
        this.raise(node2.start, "Unsyntactic " + keyword);
      }
      return this.finishNode(node2, isBreak ? "BreakStatement" : "ContinueStatement");
    };
    pp$12.parseDebuggerStatement = function(node2) {
      this.next();
      this.semicolon();
      return this.finishNode(node2, "DebuggerStatement");
    };
    pp$12.parseDoStatement = function(node2) {
      this.next();
      this.labels.push(loopLabel2);
      node2.body = this.parseStatement("do");
      this.labels.pop();
      this.expect(types2._while);
      node2.test = this.parseParenExpression();
      if (this.options.ecmaVersion >= 6) {
        this.eat(types2.semi);
      } else {
        this.semicolon();
      }
      return this.finishNode(node2, "DoWhileStatement");
    };
    pp$12.parseForStatement = function(node2) {
      this.next();
      var awaitAt = this.options.ecmaVersion >= 9 && (this.inAsync || !this.inFunction && this.options.allowAwaitOutsideFunction) && this.eatContextual("await") ? this.lastTokStart : -1;
      this.labels.push(loopLabel2);
      this.enterScope(0);
      this.expect(types2.parenL);
      if (this.type === types2.semi) {
        if (awaitAt > -1) {
          this.unexpected(awaitAt);
        }
        return this.parseFor(node2, null);
      }
      var isLet = this.isLet();
      if (this.type === types2._var || this.type === types2._const || isLet) {
        var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
        this.next();
        this.parseVar(init$1, true, kind);
        this.finishNode(init$1, "VariableDeclaration");
        if ((this.type === types2._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && init$1.declarations.length === 1) {
          if (this.options.ecmaVersion >= 9) {
            if (this.type === types2._in) {
              if (awaitAt > -1) {
                this.unexpected(awaitAt);
              }
            } else {
              node2.await = awaitAt > -1;
            }
          }
          return this.parseForIn(node2, init$1);
        }
        if (awaitAt > -1) {
          this.unexpected(awaitAt);
        }
        return this.parseFor(node2, init$1);
      }
      var refDestructuringErrors = new DestructuringErrors3();
      var init = this.parseExpression(true, refDestructuringErrors);
      if (this.type === types2._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) {
        if (this.options.ecmaVersion >= 9) {
          if (this.type === types2._in) {
            if (awaitAt > -1) {
              this.unexpected(awaitAt);
            }
          } else {
            node2.await = awaitAt > -1;
          }
        }
        this.toAssignable(init, false, refDestructuringErrors);
        this.checkLVal(init);
        return this.parseForIn(node2, init);
      } else {
        this.checkExpressionErrors(refDestructuringErrors, true);
      }
      if (awaitAt > -1) {
        this.unexpected(awaitAt);
      }
      return this.parseFor(node2, init);
    };
    pp$12.parseFunctionStatement = function(node2, isAsync, declarationPosition) {
      this.next();
      return this.parseFunction(node2, FUNC_STATEMENT2 | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT2), false, isAsync);
    };
    pp$12.parseIfStatement = function(node2) {
      this.next();
      node2.test = this.parseParenExpression();
      node2.consequent = this.parseStatement("if");
      node2.alternate = this.eat(types2._else) ? this.parseStatement("if") : null;
      return this.finishNode(node2, "IfStatement");
    };
    pp$12.parseReturnStatement = function(node2) {
      if (!this.inFunction && !this.options.allowReturnOutsideFunction) {
        this.raise(this.start, "'return' outside of function");
      }
      this.next();
      if (this.eat(types2.semi) || this.insertSemicolon()) {
        node2.argument = null;
      } else {
        node2.argument = this.parseExpression();
        this.semicolon();
      }
      return this.finishNode(node2, "ReturnStatement");
    };
    pp$12.parseSwitchStatement = function(node2) {
      this.next();
      node2.discriminant = this.parseParenExpression();
      node2.cases = [];
      this.expect(types2.braceL);
      this.labels.push(switchLabel2);
      this.enterScope(0);
      var cur;
      for (var sawDefault = false; this.type !== types2.braceR; ) {
        if (this.type === types2._case || this.type === types2._default) {
          var isCase = this.type === types2._case;
          if (cur) {
            this.finishNode(cur, "SwitchCase");
          }
          node2.cases.push(cur = this.startNode());
          cur.consequent = [];
          this.next();
          if (isCase) {
            cur.test = this.parseExpression();
          } else {
            if (sawDefault) {
              this.raiseRecoverable(this.lastTokStart, "Multiple default clauses");
            }
            sawDefault = true;
            cur.test = null;
          }
          this.expect(types2.colon);
        } else {
          if (!cur) {
            this.unexpected();
          }
          cur.consequent.push(this.parseStatement(null));
        }
      }
      this.exitScope();
      if (cur) {
        this.finishNode(cur, "SwitchCase");
      }
      this.next();
      this.labels.pop();
      return this.finishNode(node2, "SwitchStatement");
    };
    pp$12.parseThrowStatement = function(node2) {
      this.next();
      if (lineBreak2.test(this.input.slice(this.lastTokEnd, this.start))) {
        this.raise(this.lastTokEnd, "Illegal newline after throw");
      }
      node2.argument = this.parseExpression();
      this.semicolon();
      return this.finishNode(node2, "ThrowStatement");
    };
    empty2 = [];
    pp$12.parseTryStatement = function(node2) {
      this.next();
      node2.block = this.parseBlock();
      node2.handler = null;
      if (this.type === types2._catch) {
        var clause = this.startNode();
        this.next();
        if (this.eat(types2.parenL)) {
          clause.param = this.parseBindingAtom();
          var simple = clause.param.type === "Identifier";
          this.enterScope(simple ? SCOPE_SIMPLE_CATCH2 : 0);
          this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH2 : BIND_LEXICAL2);
          this.expect(types2.parenR);
        } else {
          if (this.options.ecmaVersion < 10) {
            this.unexpected();
          }
          clause.param = null;
          this.enterScope(0);
        }
        clause.body = this.parseBlock(false);
        this.exitScope();
        node2.handler = this.finishNode(clause, "CatchClause");
      }
      node2.finalizer = this.eat(types2._finally) ? this.parseBlock() : null;
      if (!node2.handler && !node2.finalizer) {
        this.raise(node2.start, "Missing catch or finally clause");
      }
      return this.finishNode(node2, "TryStatement");
    };
    pp$12.parseVarStatement = function(node2, kind) {
      this.next();
      this.parseVar(node2, false, kind);
      this.semicolon();
      return this.finishNode(node2, "VariableDeclaration");
    };
    pp$12.parseWhileStatement = function(node2) {
      this.next();
      node2.test = this.parseParenExpression();
      this.labels.push(loopLabel2);
      node2.body = this.parseStatement("while");
      this.labels.pop();
      return this.finishNode(node2, "WhileStatement");
    };
    pp$12.parseWithStatement = function(node2) {
      if (this.strict) {
        this.raise(this.start, "'with' in strict mode");
      }
      this.next();
      node2.object = this.parseParenExpression();
      node2.body = this.parseStatement("with");
      return this.finishNode(node2, "WithStatement");
    };
    pp$12.parseEmptyStatement = function(node2) {
      this.next();
      return this.finishNode(node2, "EmptyStatement");
    };
    pp$12.parseLabeledStatement = function(node2, maybeName, expr, context) {
      for (var i$1 = 0, list3 = this.labels; i$1 < list3.length; i$1 += 1) {
        var label = list3[i$1];
        if (label.name === maybeName) {
          this.raise(expr.start, "Label '" + maybeName + "' is already declared");
        }
      }
      var kind = this.type.isLoop ? "loop" : this.type === types2._switch ? "switch" : null;
      for (var i = this.labels.length - 1; i >= 0; i--) {
        var label$1 = this.labels[i];
        if (label$1.statementStart === node2.start) {
          label$1.statementStart = this.start;
          label$1.kind = kind;
        } else {
          break;
        }
      }
      this.labels.push({ name: maybeName, kind, statementStart: this.start });
      node2.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
      this.labels.pop();
      node2.label = expr;
      return this.finishNode(node2, "LabeledStatement");
    };
    pp$12.parseExpressionStatement = function(node2, expr) {
      node2.expression = expr;
      this.semicolon();
      return this.finishNode(node2, "ExpressionStatement");
    };
    pp$12.parseBlock = function(createNewLexicalScope, node2, exitStrict) {
      if (createNewLexicalScope === void 0)
        createNewLexicalScope = true;
      if (node2 === void 0)
        node2 = this.startNode();
      node2.body = [];
      this.expect(types2.braceL);
      if (createNewLexicalScope) {
        this.enterScope(0);
      }
      while (this.type !== types2.braceR) {
        var stmt = this.parseStatement(null);
        node2.body.push(stmt);
      }
      if (exitStrict) {
        this.strict = false;
      }
      this.next();
      if (createNewLexicalScope) {
        this.exitScope();
      }
      return this.finishNode(node2, "BlockStatement");
    };
    pp$12.parseFor = function(node2, init) {
      node2.init = init;
      this.expect(types2.semi);
      node2.test = this.type === types2.semi ? null : this.parseExpression();
      this.expect(types2.semi);
      node2.update = this.type === types2.parenR ? null : this.parseExpression();
      this.expect(types2.parenR);
      node2.body = this.parseStatement("for");
      this.exitScope();
      this.labels.pop();
      return this.finishNode(node2, "ForStatement");
    };
    pp$12.parseForIn = function(node2, init) {
      var isForIn = this.type === types2._in;
      this.next();
      if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.options.ecmaVersion < 8 || this.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
        this.raise(
          init.start,
          (isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer"
        );
      } else if (init.type === "AssignmentPattern") {
        this.raise(init.start, "Invalid left-hand side in for-loop");
      }
      node2.left = init;
      node2.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
      this.expect(types2.parenR);
      node2.body = this.parseStatement("for");
      this.exitScope();
      this.labels.pop();
      return this.finishNode(node2, isForIn ? "ForInStatement" : "ForOfStatement");
    };
    pp$12.parseVar = function(node2, isFor, kind) {
      node2.declarations = [];
      node2.kind = kind;
      for (; ; ) {
        var decl = this.startNode();
        this.parseVarId(decl, kind);
        if (this.eat(types2.eq)) {
          decl.init = this.parseMaybeAssign(isFor);
        } else if (kind === "const" && !(this.type === types2._in || this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
          this.unexpected();
        } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types2._in || this.isContextual("of")))) {
          this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
        } else {
          decl.init = null;
        }
        node2.declarations.push(this.finishNode(decl, "VariableDeclarator"));
        if (!this.eat(types2.comma)) {
          break;
        }
      }
      return node2;
    };
    pp$12.parseVarId = function(decl, kind) {
      decl.id = this.parseBindingAtom();
      this.checkLVal(decl.id, kind === "var" ? BIND_VAR2 : BIND_LEXICAL2, false);
    };
    FUNC_STATEMENT2 = 1;
    FUNC_HANGING_STATEMENT2 = 2;
    FUNC_NULLABLE_ID2 = 4;
    pp$12.parseFunction = function(node2, statement, allowExpressionBody, isAsync) {
      this.initFunction(node2);
      if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
        if (this.type === types2.star && statement & FUNC_HANGING_STATEMENT2) {
          this.unexpected();
        }
        node2.generator = this.eat(types2.star);
      }
      if (this.options.ecmaVersion >= 8) {
        node2.async = !!isAsync;
      }
      if (statement & FUNC_STATEMENT2) {
        node2.id = statement & FUNC_NULLABLE_ID2 && this.type !== types2.name ? null : this.parseIdent();
        if (node2.id && !(statement & FUNC_HANGING_STATEMENT2)) {
          this.checkLVal(node2.id, this.strict || node2.generator || node2.async ? this.treatFunctionsAsVar ? BIND_VAR2 : BIND_LEXICAL2 : BIND_FUNCTION2);
        }
      }
      var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
      this.yieldPos = 0;
      this.awaitPos = 0;
      this.awaitIdentPos = 0;
      this.enterScope(functionFlags2(node2.async, node2.generator));
      if (!(statement & FUNC_STATEMENT2)) {
        node2.id = this.type === types2.name ? this.parseIdent() : null;
      }
      this.parseFunctionParams(node2);
      this.parseFunctionBody(node2, allowExpressionBody, false);
      this.yieldPos = oldYieldPos;
      this.awaitPos = oldAwaitPos;
      this.awaitIdentPos = oldAwaitIdentPos;
      return this.finishNode(node2, statement & FUNC_STATEMENT2 ? "FunctionDeclaration" : "FunctionExpression");
    };
    pp$12.parseFunctionParams = function(node2) {
      this.expect(types2.parenL);
      node2.params = this.parseBindingList(types2.parenR, false, this.options.ecmaVersion >= 8);
      this.checkYieldAwaitInDefaultParams();
    };
    pp$12.parseClass = function(node2, isStatement) {
      this.next();
      var oldStrict = this.strict;
      this.strict = true;
      this.parseClassId(node2, isStatement);
      this.parseClassSuper(node2);
      var classBody = this.startNode();
      var hadConstructor = false;
      classBody.body = [];
      this.expect(types2.braceL);
      while (this.type !== types2.braceR) {
        var element2 = this.parseClassElement(node2.superClass !== null);
        if (element2) {
          classBody.body.push(element2);
          if (element2.type === "MethodDefinition" && element2.kind === "constructor") {
            if (hadConstructor) {
              this.raise(element2.start, "Duplicate constructor in the same class");
            }
            hadConstructor = true;
          }
        }
      }
      this.strict = oldStrict;
      this.next();
      node2.body = this.finishNode(classBody, "ClassBody");
      return this.finishNode(node2, isStatement ? "ClassDeclaration" : "ClassExpression");
    };
    pp$12.parseClassElement = function(constructorAllowsSuper) {
      var this$1 = this;
      if (this.eat(types2.semi)) {
        return null;
      }
      var method = this.startNode();
      var tryContextual = function(k, noLineBreak) {
        if (noLineBreak === void 0)
          noLineBreak = false;
        var start3 = this$1.start, startLoc = this$1.startLoc;
        if (!this$1.eatContextual(k)) {
          return false;
        }
        if (this$1.type !== types2.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) {
          return true;
        }
        if (method.key) {
          this$1.unexpected();
        }
        method.computed = false;
        method.key = this$1.startNodeAt(start3, startLoc);
        method.key.name = k;
        this$1.finishNode(method.key, "Identifier");
        return false;
      };
      method.kind = "method";
      method.static = tryContextual("static");
      var isGenerator = this.eat(types2.star);
      var isAsync = false;
      if (!isGenerator) {
        if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
          isAsync = true;
          isGenerator = this.options.ecmaVersion >= 9 && this.eat(types2.star);
        } else if (tryContextual("get")) {
          method.kind = "get";
        } else if (tryContextual("set")) {
          method.kind = "set";
        }
      }
      if (!method.key) {
        this.parsePropertyName(method);
      }
      var key2 = method.key;
      var allowsDirectSuper = false;
      if (!method.computed && !method.static && (key2.type === "Identifier" && key2.name === "constructor" || key2.type === "Literal" && key2.value === "constructor")) {
        if (method.kind !== "method") {
          this.raise(key2.start, "Constructor can't have get/set modifier");
        }
        if (isGenerator) {
          this.raise(key2.start, "Constructor can't be a generator");
        }
        if (isAsync) {
          this.raise(key2.start, "Constructor can't be an async method");
        }
        method.kind = "constructor";
        allowsDirectSuper = constructorAllowsSuper;
      } else if (method.static && key2.type === "Identifier" && key2.name === "prototype") {
        this.raise(key2.start, "Classes may not have a static property named prototype");
      }
      this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);
      if (method.kind === "get" && method.value.params.length !== 0) {
        this.raiseRecoverable(method.value.start, "getter should have no params");
      }
      if (method.kind === "set" && method.value.params.length !== 1) {
        this.raiseRecoverable(method.value.start, "setter should have exactly one param");
      }
      if (method.kind === "set" && method.value.params[0].type === "RestElement") {
        this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params");
      }
      return method;
    };
    pp$12.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
      method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
      return this.finishNode(method, "MethodDefinition");
    };
    pp$12.parseClassId = function(node2, isStatement) {
      if (this.type === types2.name) {
        node2.id = this.parseIdent();
        if (isStatement) {
          this.checkLVal(node2.id, BIND_LEXICAL2, false);
        }
      } else {
        if (isStatement === true) {
          this.unexpected();
        }
        node2.id = null;
      }
    };
    pp$12.parseClassSuper = function(node2) {
      node2.superClass = this.eat(types2._extends) ? this.parseExprSubscripts() : null;
    };
    pp$12.parseExport = function(node2, exports) {
      this.next();
      if (this.eat(types2.star)) {
        if (this.options.ecmaVersion >= 11) {
          if (this.eatContextual("as")) {
            node2.exported = this.parseIdent(true);
            this.checkExport(exports, node2.exported.name, this.lastTokStart);
          } else {
            node2.exported = null;
          }
        }
        this.expectContextual("from");
        if (this.type !== types2.string) {
          this.unexpected();
        }
        node2.source = this.parseExprAtom();
        this.semicolon();
        return this.finishNode(node2, "ExportAllDeclaration");
      }
      if (this.eat(types2._default)) {
        this.checkExport(exports, "default", this.lastTokStart);
        var isAsync;
        if (this.type === types2._function || (isAsync = this.isAsyncFunction())) {
          var fNode = this.startNode();
          this.next();
          if (isAsync) {
            this.next();
          }
          node2.declaration = this.parseFunction(fNode, FUNC_STATEMENT2 | FUNC_NULLABLE_ID2, false, isAsync);
        } else if (this.type === types2._class) {
          var cNode = this.startNode();
          node2.declaration = this.parseClass(cNode, "nullableID");
        } else {
          node2.declaration = this.parseMaybeAssign();
          this.semicolon();
        }
        return this.finishNode(node2, "ExportDefaultDeclaration");
      }
      if (this.shouldParseExportStatement()) {
        node2.declaration = this.parseStatement(null);
        if (node2.declaration.type === "VariableDeclaration") {
          this.checkVariableExport(exports, node2.declaration.declarations);
        } else {
          this.checkExport(exports, node2.declaration.id.name, node2.declaration.id.start);
        }
        node2.specifiers = [];
        node2.source = null;
      } else {
        node2.declaration = null;
        node2.specifiers = this.parseExportSpecifiers(exports);
        if (this.eatContextual("from")) {
          if (this.type !== types2.string) {
            this.unexpected();
          }
          node2.source = this.parseExprAtom();
        } else {
          for (var i = 0, list3 = node2.specifiers; i < list3.length; i += 1) {
            var spec = list3[i];
            this.checkUnreserved(spec.local);
            this.checkLocalExport(spec.local);
          }
          node2.source = null;
        }
        this.semicolon();
      }
      return this.finishNode(node2, "ExportNamedDeclaration");
    };
    pp$12.checkExport = function(exports, name2, pos2) {
      if (!exports) {
        return;
      }
      if (has(exports, name2)) {
        this.raiseRecoverable(pos2, "Duplicate export '" + name2 + "'");
      }
      exports[name2] = true;
    };
    pp$12.checkPatternExport = function(exports, pat) {
      var type = pat.type;
      if (type === "Identifier") {
        this.checkExport(exports, pat.name, pat.start);
      } else if (type === "ObjectPattern") {
        for (var i = 0, list3 = pat.properties; i < list3.length; i += 1) {
          var prop = list3[i];
          this.checkPatternExport(exports, prop);
        }
      } else if (type === "ArrayPattern") {
        for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
          var elt = list$1[i$1];
          if (elt) {
            this.checkPatternExport(exports, elt);
          }
        }
      } else if (type === "Property") {
        this.checkPatternExport(exports, pat.value);
      } else if (type === "AssignmentPattern") {
        this.checkPatternExport(exports, pat.left);
      } else if (type === "RestElement") {
        this.checkPatternExport(exports, pat.argument);
      } else if (type === "ParenthesizedExpression") {
        this.checkPatternExport(exports, pat.expression);
      }
    };
    pp$12.checkVariableExport = function(exports, decls) {
      if (!exports) {
        return;
      }
      for (var i = 0, list3 = decls; i < list3.length; i += 1) {
        var decl = list3[i];
        this.checkPatternExport(exports, decl.id);
      }
    };
    pp$12.shouldParseExportStatement = function() {
      return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
    };
    pp$12.parseExportSpecifiers = function(exports) {
      var nodes = [], first = true;
      this.expect(types2.braceL);
      while (!this.eat(types2.braceR)) {
        if (!first) {
          this.expect(types2.comma);
          if (this.afterTrailingComma(types2.braceR)) {
            break;
          }
        } else {
          first = false;
        }
        var node2 = this.startNode();
        node2.local = this.parseIdent(true);
        node2.exported = this.eatContextual("as") ? this.parseIdent(true) : node2.local;
        this.checkExport(exports, node2.exported.name, node2.exported.start);
        nodes.push(this.finishNode(node2, "ExportSpecifier"));
      }
      return nodes;
    };
    pp$12.parseImport = function(node2) {
      this.next();
      if (this.type === types2.string) {
        node2.specifiers = empty2;
        node2.source = this.parseExprAtom();
      } else {
        node2.specifiers = this.parseImportSpecifiers();
        this.expectContextual("from");
        node2.source = this.type === types2.string ? this.parseExprAtom() : this.unexpected();
      }
      this.semicolon();
      return this.finishNode(node2, "ImportDeclaration");
    };
    pp$12.parseImportSpecifiers = function() {
      var nodes = [], first = true;
      if (this.type === types2.name) {
        var node2 = this.startNode();
        node2.local = this.parseIdent();
        this.checkLVal(node2.local, BIND_LEXICAL2);
        nodes.push(this.finishNode(node2, "ImportDefaultSpecifier"));
        if (!this.eat(types2.comma)) {
          return nodes;
        }
      }
      if (this.type === types2.star) {
        var node$1 = this.startNode();
        this.next();
        this.expectContextual("as");
        node$1.local = this.parseIdent();
        this.checkLVal(node$1.local, BIND_LEXICAL2);
        nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
        return nodes;
      }
      this.expect(types2.braceL);
      while (!this.eat(types2.braceR)) {
        if (!first) {
          this.expect(types2.comma);
          if (this.afterTrailingComma(types2.braceR)) {
            break;
          }
        } else {
          first = false;
        }
        var node$2 = this.startNode();
        node$2.imported = this.parseIdent(true);
        if (this.eatContextual("as")) {
          node$2.local = this.parseIdent();
        } else {
          this.checkUnreserved(node$2.imported);
          node$2.local = node$2.imported;
        }
        this.checkLVal(node$2.local, BIND_LEXICAL2);
        nodes.push(this.finishNode(node$2, "ImportSpecifier"));
      }
      return nodes;
    };
    pp$12.adaptDirectivePrologue = function(statements) {
      for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
        statements[i].directive = statements[i].expression.raw.slice(1, -1);
      }
    };
    pp$12.isDirectiveCandidate = function(statement) {
      return statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string" && // Reject parenthesized strings.
      (this.input[statement.start] === '"' || this.input[statement.start] === "'");
    };
    pp$22 = Parser3.prototype;
    pp$22.toAssignable = function(node2, isBinding, refDestructuringErrors) {
      if (this.options.ecmaVersion >= 6 && node2) {
        switch (node2.type) {
          case "Identifier":
            if (this.inAsync && node2.name === "await") {
              this.raise(node2.start, "Cannot use 'await' as identifier inside an async function");
            }
            break;
          case "ObjectPattern":
          case "ArrayPattern":
          case "RestElement":
            break;
          case "ObjectExpression":
            node2.type = "ObjectPattern";
            if (refDestructuringErrors) {
              this.checkPatternErrors(refDestructuringErrors, true);
            }
            for (var i = 0, list3 = node2.properties; i < list3.length; i += 1) {
              var prop = list3[i];
              this.toAssignable(prop, isBinding);
              if (prop.type === "RestElement" && (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")) {
                this.raise(prop.argument.start, "Unexpected token");
              }
            }
            break;
          case "Property":
            if (node2.kind !== "init") {
              this.raise(node2.key.start, "Object pattern can't contain getter or setter");
            }
            this.toAssignable(node2.value, isBinding);
            break;
          case "ArrayExpression":
            node2.type = "ArrayPattern";
            if (refDestructuringErrors) {
              this.checkPatternErrors(refDestructuringErrors, true);
            }
            this.toAssignableList(node2.elements, isBinding);
            break;
          case "SpreadElement":
            node2.type = "RestElement";
            this.toAssignable(node2.argument, isBinding);
            if (node2.argument.type === "AssignmentPattern") {
              this.raise(node2.argument.start, "Rest elements cannot have a default value");
            }
            break;
          case "AssignmentExpression":
            if (node2.operator !== "=") {
              this.raise(node2.left.end, "Only '=' operator can be used for specifying default value.");
            }
            node2.type = "AssignmentPattern";
            delete node2.operator;
            this.toAssignable(node2.left, isBinding);
          case "AssignmentPattern":
            break;
          case "ParenthesizedExpression":
            this.toAssignable(node2.expression, isBinding, refDestructuringErrors);
            break;
          case "ChainExpression":
            this.raiseRecoverable(node2.start, "Optional chaining cannot appear in left-hand side");
            break;
          case "MemberExpression":
            if (!isBinding) {
              break;
            }
          default:
            this.raise(node2.start, "Assigning to rvalue");
        }
      } else if (refDestructuringErrors) {
        this.checkPatternErrors(refDestructuringErrors, true);
      }
      return node2;
    };
    pp$22.toAssignableList = function(exprList, isBinding) {
      var end = exprList.length;
      for (var i = 0; i < end; i++) {
        var elt = exprList[i];
        if (elt) {
          this.toAssignable(elt, isBinding);
        }
      }
      if (end) {
        var last = exprList[end - 1];
        if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier") {
          this.unexpected(last.argument.start);
        }
      }
      return exprList;
    };
    pp$22.parseSpread = function(refDestructuringErrors) {
      var node2 = this.startNode();
      this.next();
      node2.argument = this.parseMaybeAssign(false, refDestructuringErrors);
      return this.finishNode(node2, "SpreadElement");
    };
    pp$22.parseRestBinding = function() {
      var node2 = this.startNode();
      this.next();
      if (this.options.ecmaVersion === 6 && this.type !== types2.name) {
        this.unexpected();
      }
      node2.argument = this.parseBindingAtom();
      return this.finishNode(node2, "RestElement");
    };
    pp$22.parseBindingAtom = function() {
      if (this.options.ecmaVersion >= 6) {
        switch (this.type) {
          case types2.bracketL:
            var node2 = this.startNode();
            this.next();
            node2.elements = this.parseBindingList(types2.bracketR, true, true);
            return this.finishNode(node2, "ArrayPattern");
          case types2.braceL:
            return this.parseObj(true);
        }
      }
      return this.parseIdent();
    };
    pp$22.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
      var elts = [], first = true;
      while (!this.eat(close)) {
        if (first) {
          first = false;
        } else {
          this.expect(types2.comma);
        }
        if (allowEmpty && this.type === types2.comma) {
          elts.push(null);
        } else if (allowTrailingComma && this.afterTrailingComma(close)) {
          break;
        } else if (this.type === types2.ellipsis) {
          var rest = this.parseRestBinding();
          this.parseBindingListItem(rest);
          elts.push(rest);
          if (this.type === types2.comma) {
            this.raise(this.start, "Comma is not permitted after the rest element");
          }
          this.expect(close);
          break;
        } else {
          var elem = this.parseMaybeDefault(this.start, this.startLoc);
          this.parseBindingListItem(elem);
          elts.push(elem);
        }
      }
      return elts;
    };
    pp$22.parseBindingListItem = function(param) {
      return param;
    };
    pp$22.parseMaybeDefault = function(startPos, startLoc, left) {
      left = left || this.parseBindingAtom();
      if (this.options.ecmaVersion < 6 || !this.eat(types2.eq)) {
        return left;
      }
      var node2 = this.startNodeAt(startPos, startLoc);
      node2.left = left;
      node2.right = this.parseMaybeAssign();
      return this.finishNode(node2, "AssignmentPattern");
    };
    pp$22.checkLVal = function(expr, bindingType, checkClashes) {
      if (bindingType === void 0)
        bindingType = BIND_NONE2;
      switch (expr.type) {
        case "Identifier":
          if (bindingType === BIND_LEXICAL2 && expr.name === "let") {
            this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name");
          }
          if (this.strict && this.reservedWordsStrictBind.test(expr.name)) {
            this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
          }
          if (checkClashes) {
            if (has(checkClashes, expr.name)) {
              this.raiseRecoverable(expr.start, "Argument name clash");
            }
            checkClashes[expr.name] = true;
          }
          if (bindingType !== BIND_NONE2 && bindingType !== BIND_OUTSIDE2) {
            this.declareName(expr.name, bindingType, expr.start);
          }
          break;
        case "ChainExpression":
          this.raiseRecoverable(expr.start, "Optional chaining cannot appear in left-hand side");
          break;
        case "MemberExpression":
          if (bindingType) {
            this.raiseRecoverable(expr.start, "Binding member expression");
          }
          break;
        case "ObjectPattern":
          for (var i = 0, list3 = expr.properties; i < list3.length; i += 1) {
            var prop = list3[i];
            this.checkLVal(prop, bindingType, checkClashes);
          }
          break;
        case "Property":
          this.checkLVal(expr.value, bindingType, checkClashes);
          break;
        case "ArrayPattern":
          for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
            var elem = list$1[i$1];
            if (elem) {
              this.checkLVal(elem, bindingType, checkClashes);
            }
          }
          break;
        case "AssignmentPattern":
          this.checkLVal(expr.left, bindingType, checkClashes);
          break;
        case "RestElement":
          this.checkLVal(expr.argument, bindingType, checkClashes);
          break;
        case "ParenthesizedExpression":
          this.checkLVal(expr.expression, bindingType, checkClashes);
          break;
        default:
          this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
      }
    };
    pp$32 = Parser3.prototype;
    pp$32.checkPropClash = function(prop, propHash, refDestructuringErrors) {
      if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement") {
        return;
      }
      if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand)) {
        return;
      }
      var key2 = prop.key;
      var name2;
      switch (key2.type) {
        case "Identifier":
          name2 = key2.name;
          break;
        case "Literal":
          name2 = String(key2.value);
          break;
        default:
          return;
      }
      var kind = prop.kind;
      if (this.options.ecmaVersion >= 6) {
        if (name2 === "__proto__" && kind === "init") {
          if (propHash.proto) {
            if (refDestructuringErrors) {
              if (refDestructuringErrors.doubleProto < 0) {
                refDestructuringErrors.doubleProto = key2.start;
              }
            } else {
              this.raiseRecoverable(key2.start, "Redefinition of __proto__ property");
            }
          }
          propHash.proto = true;
        }
        return;
      }
      name2 = "$" + name2;
      var other = propHash[name2];
      if (other) {
        var redefinition;
        if (kind === "init") {
          redefinition = this.strict && other.init || other.get || other.set;
        } else {
          redefinition = other.init || other[kind];
        }
        if (redefinition) {
          this.raiseRecoverable(key2.start, "Redefinition of property");
        }
      } else {
        other = propHash[name2] = {
          init: false,
          get: false,
          set: false
        };
      }
      other[kind] = true;
    };
    pp$32.parseExpression = function(noIn, refDestructuringErrors) {
      var startPos = this.start, startLoc = this.startLoc;
      var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
      if (this.type === types2.comma) {
        var node2 = this.startNodeAt(startPos, startLoc);
        node2.expressions = [expr];
        while (this.eat(types2.comma)) {
          node2.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors));
        }
        return this.finishNode(node2, "SequenceExpression");
      }
      return expr;
    };
    pp$32.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
      if (this.isContextual("yield")) {
        if (this.inGenerator) {
          return this.parseYield(noIn);
        } else {
          this.exprAllowed = false;
        }
      }
      var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;
      if (refDestructuringErrors) {
        oldParenAssign = refDestructuringErrors.parenthesizedAssign;
        oldTrailingComma = refDestructuringErrors.trailingComma;
        refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
      } else {
        refDestructuringErrors = new DestructuringErrors3();
        ownDestructuringErrors = true;
      }
      var startPos = this.start, startLoc = this.startLoc;
      if (this.type === types2.parenL || this.type === types2.name) {
        this.potentialArrowAt = this.start;
      }
      var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
      if (afterLeftParse) {
        left = afterLeftParse.call(this, left, startPos, startLoc);
      }
      if (this.type.isAssign) {
        var node2 = this.startNodeAt(startPos, startLoc);
        node2.operator = this.value;
        node2.left = this.type === types2.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
        if (!ownDestructuringErrors) {
          refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
        }
        if (refDestructuringErrors.shorthandAssign >= node2.left.start) {
          refDestructuringErrors.shorthandAssign = -1;
        }
        this.checkLVal(left);
        this.next();
        node2.right = this.parseMaybeAssign(noIn);
        return this.finishNode(node2, "AssignmentExpression");
      } else {
        if (ownDestructuringErrors) {
          this.checkExpressionErrors(refDestructuringErrors, true);
        }
      }
      if (oldParenAssign > -1) {
        refDestructuringErrors.parenthesizedAssign = oldParenAssign;
      }
      if (oldTrailingComma > -1) {
        refDestructuringErrors.trailingComma = oldTrailingComma;
      }
      return left;
    };
    pp$32.parseMaybeConditional = function(noIn, refDestructuringErrors) {
      var startPos = this.start, startLoc = this.startLoc;
      var expr = this.parseExprOps(noIn, refDestructuringErrors);
      if (this.checkExpressionErrors(refDestructuringErrors)) {
        return expr;
      }
      if (this.eat(types2.question)) {
        var node2 = this.startNodeAt(startPos, startLoc);
        node2.test = expr;
        node2.consequent = this.parseMaybeAssign();
        this.expect(types2.colon);
        node2.alternate = this.parseMaybeAssign(noIn);
        return this.finishNode(node2, "ConditionalExpression");
      }
      return expr;
    };
    pp$32.parseExprOps = function(noIn, refDestructuringErrors) {
      var startPos = this.start, startLoc = this.startLoc;
      var expr = this.parseMaybeUnary(refDestructuringErrors, false);
      if (this.checkExpressionErrors(refDestructuringErrors)) {
        return expr;
      }
      return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn);
    };
    pp$32.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
      var prec = this.type.binop;
      if (prec != null && (!noIn || this.type !== types2._in)) {
        if (prec > minPrec) {
          var logical = this.type === types2.logicalOR || this.type === types2.logicalAND;
          var coalesce = this.type === types2.coalesce;
          if (coalesce) {
            prec = types2.logicalAND.binop;
          }
          var op = this.value;
          this.next();
          var startPos = this.start, startLoc = this.startLoc;
          var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
          var node2 = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
          if (logical && this.type === types2.coalesce || coalesce && (this.type === types2.logicalOR || this.type === types2.logicalAND)) {
            this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
          }
          return this.parseExprOp(node2, leftStartPos, leftStartLoc, minPrec, noIn);
        }
      }
      return left;
    };
    pp$32.buildBinary = function(startPos, startLoc, left, right, op, logical) {
      var node2 = this.startNodeAt(startPos, startLoc);
      node2.left = left;
      node2.operator = op;
      node2.right = right;
      return this.finishNode(node2, logical ? "LogicalExpression" : "BinaryExpression");
    };
    pp$32.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
      var startPos = this.start, startLoc = this.startLoc, expr;
      if (this.isContextual("await") && (this.inAsync || !this.inFunction && this.options.allowAwaitOutsideFunction)) {
        expr = this.parseAwait();
        sawUnary = true;
      } else if (this.type.prefix) {
        var node2 = this.startNode(), update = this.type === types2.incDec;
        node2.operator = this.value;
        node2.prefix = true;
        this.next();
        node2.argument = this.parseMaybeUnary(null, true);
        this.checkExpressionErrors(refDestructuringErrors, true);
        if (update) {
          this.checkLVal(node2.argument);
        } else if (this.strict && node2.operator === "delete" && node2.argument.type === "Identifier") {
          this.raiseRecoverable(node2.start, "Deleting local variable in strict mode");
        } else {
          sawUnary = true;
        }
        expr = this.finishNode(node2, update ? "UpdateExpression" : "UnaryExpression");
      } else {
        expr = this.parseExprSubscripts(refDestructuringErrors);
        if (this.checkExpressionErrors(refDestructuringErrors)) {
          return expr;
        }
        while (this.type.postfix && !this.canInsertSemicolon()) {
          var node$1 = this.startNodeAt(startPos, startLoc);
          node$1.operator = this.value;
          node$1.prefix = false;
          node$1.argument = expr;
          this.checkLVal(expr);
          this.next();
          expr = this.finishNode(node$1, "UpdateExpression");
        }
      }
      if (!sawUnary && this.eat(types2.starstar)) {
        return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false);
      } else {
        return expr;
      }
    };
    pp$32.parseExprSubscripts = function(refDestructuringErrors) {
      var startPos = this.start, startLoc = this.startLoc;
      var expr = this.parseExprAtom(refDestructuringErrors);
      if (expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")") {
        return expr;
      }
      var result = this.parseSubscripts(expr, startPos, startLoc);
      if (refDestructuringErrors && result.type === "MemberExpression") {
        if (refDestructuringErrors.parenthesizedAssign >= result.start) {
          refDestructuringErrors.parenthesizedAssign = -1;
        }
        if (refDestructuringErrors.parenthesizedBind >= result.start) {
          refDestructuringErrors.parenthesizedBind = -1;
        }
      }
      return result;
    };
    pp$32.parseSubscripts = function(base2, startPos, startLoc, noCalls) {
      var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base2.type === "Identifier" && base2.name === "async" && this.lastTokEnd === base2.end && !this.canInsertSemicolon() && base2.end - base2.start === 5 && this.potentialArrowAt === base2.start;
      var optionalChained = false;
      while (true) {
        var element2 = this.parseSubscript(base2, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained);
        if (element2.optional) {
          optionalChained = true;
        }
        if (element2 === base2 || element2.type === "ArrowFunctionExpression") {
          if (optionalChained) {
            var chainNode = this.startNodeAt(startPos, startLoc);
            chainNode.expression = element2;
            element2 = this.finishNode(chainNode, "ChainExpression");
          }
          return element2;
        }
        base2 = element2;
      }
    };
    pp$32.parseSubscript = function(base2, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained) {
      var optionalSupported = this.options.ecmaVersion >= 11;
      var optional = optionalSupported && this.eat(types2.questionDot);
      if (noCalls && optional) {
        this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions");
      }
      var computed = this.eat(types2.bracketL);
      if (computed || optional && this.type !== types2.parenL && this.type !== types2.backQuote || this.eat(types2.dot)) {
        var node2 = this.startNodeAt(startPos, startLoc);
        node2.object = base2;
        node2.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
        node2.computed = !!computed;
        if (computed) {
          this.expect(types2.bracketR);
        }
        if (optionalSupported) {
          node2.optional = optional;
        }
        base2 = this.finishNode(node2, "MemberExpression");
      } else if (!noCalls && this.eat(types2.parenL)) {
        var refDestructuringErrors = new DestructuringErrors3(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
        this.yieldPos = 0;
        this.awaitPos = 0;
        this.awaitIdentPos = 0;
        var exprList = this.parseExprList(types2.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);
        if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(types2.arrow)) {
          this.checkPatternErrors(refDestructuringErrors, false);
          this.checkYieldAwaitInDefaultParams();
          if (this.awaitIdentPos > 0) {
            this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function");
          }
          this.yieldPos = oldYieldPos;
          this.awaitPos = oldAwaitPos;
          this.awaitIdentPos = oldAwaitIdentPos;
          return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true);
        }
        this.checkExpressionErrors(refDestructuringErrors, true);
        this.yieldPos = oldYieldPos || this.yieldPos;
        this.awaitPos = oldAwaitPos || this.awaitPos;
        this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;
        var node$1 = this.startNodeAt(startPos, startLoc);
        node$1.callee = base2;
        node$1.arguments = exprList;
        if (optionalSupported) {
          node$1.optional = optional;
        }
        base2 = this.finishNode(node$1, "CallExpression");
      } else if (this.type === types2.backQuote) {
        if (optional || optionalChained) {
          this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
        }
        var node$2 = this.startNodeAt(startPos, startLoc);
        node$2.tag = base2;
        node$2.quasi = this.parseTemplate({ isTagged: true });
        base2 = this.finishNode(node$2, "TaggedTemplateExpression");
      }
      return base2;
    };
    pp$32.parseExprAtom = function(refDestructuringErrors) {
      if (this.type === types2.slash) {
        this.readRegexp();
      }
      var node2, canBeArrow = this.potentialArrowAt === this.start;
      switch (this.type) {
        case types2._super:
          if (!this.allowSuper) {
            this.raise(this.start, "'super' keyword outside a method");
          }
          node2 = this.startNode();
          this.next();
          if (this.type === types2.parenL && !this.allowDirectSuper) {
            this.raise(node2.start, "super() call outside constructor of a subclass");
          }
          if (this.type !== types2.dot && this.type !== types2.bracketL && this.type !== types2.parenL) {
            this.unexpected();
          }
          return this.finishNode(node2, "Super");
        case types2._this:
          node2 = this.startNode();
          this.next();
          return this.finishNode(node2, "ThisExpression");
        case types2.name:
          var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
          var id = this.parseIdent(false);
          if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types2._function)) {
            return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true);
          }
          if (canBeArrow && !this.canInsertSemicolon()) {
            if (this.eat(types2.arrow)) {
              return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false);
            }
            if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types2.name && !containsEsc) {
              id = this.parseIdent(false);
              if (this.canInsertSemicolon() || !this.eat(types2.arrow)) {
                this.unexpected();
              }
              return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true);
            }
          }
          return id;
        case types2.regexp:
          var value2 = this.value;
          node2 = this.parseLiteral(value2.value);
          node2.regex = { pattern: value2.pattern, flags: value2.flags };
          return node2;
        case types2.num:
        case types2.string:
          return this.parseLiteral(this.value);
        case types2._null:
        case types2._true:
        case types2._false:
          node2 = this.startNode();
          node2.value = this.type === types2._null ? null : this.type === types2._true;
          node2.raw = this.type.keyword;
          this.next();
          return this.finishNode(node2, "Literal");
        case types2.parenL:
          var start3 = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
          if (refDestructuringErrors) {
            if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr)) {
              refDestructuringErrors.parenthesizedAssign = start3;
            }
            if (refDestructuringErrors.parenthesizedBind < 0) {
              refDestructuringErrors.parenthesizedBind = start3;
            }
          }
          return expr;
        case types2.bracketL:
          node2 = this.startNode();
          this.next();
          node2.elements = this.parseExprList(types2.bracketR, true, true, refDestructuringErrors);
          return this.finishNode(node2, "ArrayExpression");
        case types2.braceL:
          return this.parseObj(false, refDestructuringErrors);
        case types2._function:
          node2 = this.startNode();
          this.next();
          return this.parseFunction(node2, 0);
        case types2._class:
          return this.parseClass(this.startNode(), false);
        case types2._new:
          return this.parseNew();
        case types2.backQuote:
          return this.parseTemplate();
        case types2._import:
          if (this.options.ecmaVersion >= 11) {
            return this.parseExprImport();
          } else {
            return this.unexpected();
          }
        default:
          this.unexpected();
      }
    };
    pp$32.parseExprImport = function() {
      var node2 = this.startNode();
      if (this.containsEsc) {
        this.raiseRecoverable(this.start, "Escape sequence in keyword import");
      }
      var meta = this.parseIdent(true);
      switch (this.type) {
        case types2.parenL:
          return this.parseDynamicImport(node2);
        case types2.dot:
          node2.meta = meta;
          return this.parseImportMeta(node2);
        default:
          this.unexpected();
      }
    };
    pp$32.parseDynamicImport = function(node2) {
      this.next();
      node2.source = this.parseMaybeAssign();
      if (!this.eat(types2.parenR)) {
        var errorPos = this.start;
        if (this.eat(types2.comma) && this.eat(types2.parenR)) {
          this.raiseRecoverable(errorPos, "Trailing comma is not allowed in import()");
        } else {
          this.unexpected(errorPos);
        }
      }
      return this.finishNode(node2, "ImportExpression");
    };
    pp$32.parseImportMeta = function(node2) {
      this.next();
      var containsEsc = this.containsEsc;
      node2.property = this.parseIdent(true);
      if (node2.property.name !== "meta") {
        this.raiseRecoverable(node2.property.start, "The only valid meta property for import is 'import.meta'");
      }
      if (containsEsc) {
        this.raiseRecoverable(node2.start, "'import.meta' must not contain escaped characters");
      }
      if (this.options.sourceType !== "module") {
        this.raiseRecoverable(node2.start, "Cannot use 'import.meta' outside a module");
      }
      return this.finishNode(node2, "MetaProperty");
    };
    pp$32.parseLiteral = function(value2) {
      var node2 = this.startNode();
      node2.value = value2;
      node2.raw = this.input.slice(this.start, this.end);
      if (node2.raw.charCodeAt(node2.raw.length - 1) === 110) {
        node2.bigint = node2.raw.slice(0, -1).replace(/_/g, "");
      }
      this.next();
      return this.finishNode(node2, "Literal");
    };
    pp$32.parseParenExpression = function() {
      this.expect(types2.parenL);
      var val = this.parseExpression();
      this.expect(types2.parenR);
      return val;
    };
    pp$32.parseParenAndDistinguishExpression = function(canBeArrow) {
      var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
      if (this.options.ecmaVersion >= 6) {
        this.next();
        var innerStartPos = this.start, innerStartLoc = this.startLoc;
        var exprList = [], first = true, lastIsComma = false;
        var refDestructuringErrors = new DestructuringErrors3(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
        this.yieldPos = 0;
        this.awaitPos = 0;
        while (this.type !== types2.parenR) {
          first ? first = false : this.expect(types2.comma);
          if (allowTrailingComma && this.afterTrailingComma(types2.parenR, true)) {
            lastIsComma = true;
            break;
          } else if (this.type === types2.ellipsis) {
            spreadStart = this.start;
            exprList.push(this.parseParenItem(this.parseRestBinding()));
            if (this.type === types2.comma) {
              this.raise(this.start, "Comma is not permitted after the rest element");
            }
            break;
          } else {
            exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));
          }
        }
        var innerEndPos = this.start, innerEndLoc = this.startLoc;
        this.expect(types2.parenR);
        if (canBeArrow && !this.canInsertSemicolon() && this.eat(types2.arrow)) {
          this.checkPatternErrors(refDestructuringErrors, false);
          this.checkYieldAwaitInDefaultParams();
          this.yieldPos = oldYieldPos;
          this.awaitPos = oldAwaitPos;
          return this.parseParenArrowList(startPos, startLoc, exprList);
        }
        if (!exprList.length || lastIsComma) {
          this.unexpected(this.lastTokStart);
        }
        if (spreadStart) {
          this.unexpected(spreadStart);
        }
        this.checkExpressionErrors(refDestructuringErrors, true);
        this.yieldPos = oldYieldPos || this.yieldPos;
        this.awaitPos = oldAwaitPos || this.awaitPos;
        if (exprList.length > 1) {
          val = this.startNodeAt(innerStartPos, innerStartLoc);
          val.expressions = exprList;
          this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
        } else {
          val = exprList[0];
        }
      } else {
        val = this.parseParenExpression();
      }
      if (this.options.preserveParens) {
        var par = this.startNodeAt(startPos, startLoc);
        par.expression = val;
        return this.finishNode(par, "ParenthesizedExpression");
      } else {
        return val;
      }
    };
    pp$32.parseParenItem = function(item) {
      return item;
    };
    pp$32.parseParenArrowList = function(startPos, startLoc, exprList) {
      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList);
    };
    empty$12 = [];
    pp$32.parseNew = function() {
      if (this.containsEsc) {
        this.raiseRecoverable(this.start, "Escape sequence in keyword new");
      }
      var node2 = this.startNode();
      var meta = this.parseIdent(true);
      if (this.options.ecmaVersion >= 6 && this.eat(types2.dot)) {
        node2.meta = meta;
        var containsEsc = this.containsEsc;
        node2.property = this.parseIdent(true);
        if (node2.property.name !== "target") {
          this.raiseRecoverable(node2.property.start, "The only valid meta property for new is 'new.target'");
        }
        if (containsEsc) {
          this.raiseRecoverable(node2.start, "'new.target' must not contain escaped characters");
        }
        if (!this.inNonArrowFunction()) {
          this.raiseRecoverable(node2.start, "'new.target' can only be used in functions");
        }
        return this.finishNode(node2, "MetaProperty");
      }
      var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types2._import;
      node2.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
      if (isImport && node2.callee.type === "ImportExpression") {
        this.raise(startPos, "Cannot use new with import()");
      }
      if (this.eat(types2.parenL)) {
        node2.arguments = this.parseExprList(types2.parenR, this.options.ecmaVersion >= 8, false);
      } else {
        node2.arguments = empty$12;
      }
      return this.finishNode(node2, "NewExpression");
    };
    pp$32.parseTemplateElement = function(ref3) {
      var isTagged = ref3.isTagged;
      var elem = this.startNode();
      if (this.type === types2.invalidTemplate) {
        if (!isTagged) {
          this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
        }
        elem.value = {
          raw: this.value,
          cooked: null
        };
      } else {
        elem.value = {
          raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
          cooked: this.value
        };
      }
      this.next();
      elem.tail = this.type === types2.backQuote;
      return this.finishNode(elem, "TemplateElement");
    };
    pp$32.parseTemplate = function(ref3) {
      if (ref3 === void 0)
        ref3 = {};
      var isTagged = ref3.isTagged;
      if (isTagged === void 0)
        isTagged = false;
      var node2 = this.startNode();
      this.next();
      node2.expressions = [];
      var curElt = this.parseTemplateElement({ isTagged });
      node2.quasis = [curElt];
      while (!curElt.tail) {
        if (this.type === types2.eof) {
          this.raise(this.pos, "Unterminated template literal");
        }
        this.expect(types2.dollarBraceL);
        node2.expressions.push(this.parseExpression());
        this.expect(types2.braceR);
        node2.quasis.push(curElt = this.parseTemplateElement({ isTagged }));
      }
      this.next();
      return this.finishNode(node2, "TemplateLiteral");
    };
    pp$32.isAsyncProp = function(prop) {
      return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && (this.type === types2.name || this.type === types2.num || this.type === types2.string || this.type === types2.bracketL || this.type.keyword || this.options.ecmaVersion >= 9 && this.type === types2.star) && !lineBreak2.test(this.input.slice(this.lastTokEnd, this.start));
    };
    pp$32.parseObj = function(isPattern, refDestructuringErrors) {
      var node2 = this.startNode(), first = true, propHash = {};
      node2.properties = [];
      this.next();
      while (!this.eat(types2.braceR)) {
        if (!first) {
          this.expect(types2.comma);
          if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types2.braceR)) {
            break;
          }
        } else {
          first = false;
        }
        var prop = this.parseProperty(isPattern, refDestructuringErrors);
        if (!isPattern) {
          this.checkPropClash(prop, propHash, refDestructuringErrors);
        }
        node2.properties.push(prop);
      }
      return this.finishNode(node2, isPattern ? "ObjectPattern" : "ObjectExpression");
    };
    pp$32.parseProperty = function(isPattern, refDestructuringErrors) {
      var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
      if (this.options.ecmaVersion >= 9 && this.eat(types2.ellipsis)) {
        if (isPattern) {
          prop.argument = this.parseIdent(false);
          if (this.type === types2.comma) {
            this.raise(this.start, "Comma is not permitted after the rest element");
          }
          return this.finishNode(prop, "RestElement");
        }
        if (this.type === types2.parenL && refDestructuringErrors) {
          if (refDestructuringErrors.parenthesizedAssign < 0) {
            refDestructuringErrors.parenthesizedAssign = this.start;
          }
          if (refDestructuringErrors.parenthesizedBind < 0) {
            refDestructuringErrors.parenthesizedBind = this.start;
          }
        }
        prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
        if (this.type === types2.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
          refDestructuringErrors.trailingComma = this.start;
        }
        return this.finishNode(prop, "SpreadElement");
      }
      if (this.options.ecmaVersion >= 6) {
        prop.method = false;
        prop.shorthand = false;
        if (isPattern || refDestructuringErrors) {
          startPos = this.start;
          startLoc = this.startLoc;
        }
        if (!isPattern) {
          isGenerator = this.eat(types2.star);
        }
      }
      var containsEsc = this.containsEsc;
      this.parsePropertyName(prop);
      if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
        isAsync = true;
        isGenerator = this.options.ecmaVersion >= 9 && this.eat(types2.star);
        this.parsePropertyName(prop, refDestructuringErrors);
      } else {
        isAsync = false;
      }
      this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
      return this.finishNode(prop, "Property");
    };
    pp$32.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
      if ((isGenerator || isAsync) && this.type === types2.colon) {
        this.unexpected();
      }
      if (this.eat(types2.colon)) {
        prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
        prop.kind = "init";
      } else if (this.options.ecmaVersion >= 6 && this.type === types2.parenL) {
        if (isPattern) {
          this.unexpected();
        }
        prop.kind = "init";
        prop.method = true;
        prop.value = this.parseMethod(isGenerator, isAsync);
      } else if (!isPattern && !containsEsc && this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (this.type !== types2.comma && this.type !== types2.braceR && this.type !== types2.eq)) {
        if (isGenerator || isAsync) {
          this.unexpected();
        }
        prop.kind = prop.key.name;
        this.parsePropertyName(prop);
        prop.value = this.parseMethod(false);
        var paramCount = prop.kind === "get" ? 0 : 1;
        if (prop.value.params.length !== paramCount) {
          var start3 = prop.value.start;
          if (prop.kind === "get") {
            this.raiseRecoverable(start3, "getter should have no params");
          } else {
            this.raiseRecoverable(start3, "setter should have exactly one param");
          }
        } else {
          if (prop.kind === "set" && prop.value.params[0].type === "RestElement") {
            this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params");
          }
        }
      } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
        if (isGenerator || isAsync) {
          this.unexpected();
        }
        this.checkUnreserved(prop.key);
        if (prop.key.name === "await" && !this.awaitIdentPos) {
          this.awaitIdentPos = startPos;
        }
        prop.kind = "init";
        if (isPattern) {
          prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
        } else if (this.type === types2.eq && refDestructuringErrors) {
          if (refDestructuringErrors.shorthandAssign < 0) {
            refDestructuringErrors.shorthandAssign = this.start;
          }
          prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
        } else {
          prop.value = prop.key;
        }
        prop.shorthand = true;
      } else {
        this.unexpected();
      }
    };
    pp$32.parsePropertyName = function(prop) {
      if (this.options.ecmaVersion >= 6) {
        if (this.eat(types2.bracketL)) {
          prop.computed = true;
          prop.key = this.parseMaybeAssign();
          this.expect(types2.bracketR);
          return prop.key;
        } else {
          prop.computed = false;
        }
      }
      return prop.key = this.type === types2.num || this.type === types2.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never");
    };
    pp$32.initFunction = function(node2) {
      node2.id = null;
      if (this.options.ecmaVersion >= 6) {
        node2.generator = node2.expression = false;
      }
      if (this.options.ecmaVersion >= 8) {
        node2.async = false;
      }
    };
    pp$32.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
      var node2 = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
      this.initFunction(node2);
      if (this.options.ecmaVersion >= 6) {
        node2.generator = isGenerator;
      }
      if (this.options.ecmaVersion >= 8) {
        node2.async = !!isAsync;
      }
      this.yieldPos = 0;
      this.awaitPos = 0;
      this.awaitIdentPos = 0;
      this.enterScope(functionFlags2(isAsync, node2.generator) | SCOPE_SUPER2 | (allowDirectSuper ? SCOPE_DIRECT_SUPER2 : 0));
      this.expect(types2.parenL);
      node2.params = this.parseBindingList(types2.parenR, false, this.options.ecmaVersion >= 8);
      this.checkYieldAwaitInDefaultParams();
      this.parseFunctionBody(node2, false, true);
      this.yieldPos = oldYieldPos;
      this.awaitPos = oldAwaitPos;
      this.awaitIdentPos = oldAwaitIdentPos;
      return this.finishNode(node2, "FunctionExpression");
    };
    pp$32.parseArrowExpression = function(node2, params, isAsync) {
      var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
      this.enterScope(functionFlags2(isAsync, false) | SCOPE_ARROW2);
      this.initFunction(node2);
      if (this.options.ecmaVersion >= 8) {
        node2.async = !!isAsync;
      }
      this.yieldPos = 0;
      this.awaitPos = 0;
      this.awaitIdentPos = 0;
      node2.params = this.toAssignableList(params, true);
      this.parseFunctionBody(node2, true, false);
      this.yieldPos = oldYieldPos;
      this.awaitPos = oldAwaitPos;
      this.awaitIdentPos = oldAwaitIdentPos;
      return this.finishNode(node2, "ArrowFunctionExpression");
    };
    pp$32.parseFunctionBody = function(node2, isArrowFunction, isMethod) {
      var isExpression = isArrowFunction && this.type !== types2.braceL;
      var oldStrict = this.strict, useStrict = false;
      if (isExpression) {
        node2.body = this.parseMaybeAssign();
        node2.expression = true;
        this.checkParams(node2, false);
      } else {
        var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node2.params);
        if (!oldStrict || nonSimple) {
          useStrict = this.strictDirective(this.end);
          if (useStrict && nonSimple) {
            this.raiseRecoverable(node2.start, "Illegal 'use strict' directive in function with non-simple parameter list");
          }
        }
        var oldLabels = this.labels;
        this.labels = [];
        if (useStrict) {
          this.strict = true;
        }
        this.checkParams(node2, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node2.params));
        if (this.strict && node2.id) {
          this.checkLVal(node2.id, BIND_OUTSIDE2);
        }
        node2.body = this.parseBlock(false, void 0, useStrict && !oldStrict);
        node2.expression = false;
        this.adaptDirectivePrologue(node2.body.body);
        this.labels = oldLabels;
      }
      this.exitScope();
    };
    pp$32.isSimpleParamList = function(params) {
      for (var i = 0, list3 = params; i < list3.length; i += 1) {
        var param = list3[i];
        if (param.type !== "Identifier") {
          return false;
        }
      }
      return true;
    };
    pp$32.checkParams = function(node2, allowDuplicates) {
      var nameHash = {};
      for (var i = 0, list3 = node2.params; i < list3.length; i += 1) {
        var param = list3[i];
        this.checkLVal(param, BIND_VAR2, allowDuplicates ? null : nameHash);
      }
    };
    pp$32.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
      var elts = [], first = true;
      while (!this.eat(close)) {
        if (!first) {
          this.expect(types2.comma);
          if (allowTrailingComma && this.afterTrailingComma(close)) {
            break;
          }
        } else {
          first = false;
        }
        var elt = void 0;
        if (allowEmpty && this.type === types2.comma) {
          elt = null;
        } else if (this.type === types2.ellipsis) {
          elt = this.parseSpread(refDestructuringErrors);
          if (refDestructuringErrors && this.type === types2.comma && refDestructuringErrors.trailingComma < 0) {
            refDestructuringErrors.trailingComma = this.start;
          }
        } else {
          elt = this.parseMaybeAssign(false, refDestructuringErrors);
        }
        elts.push(elt);
      }
      return elts;
    };
    pp$32.checkUnreserved = function(ref3) {
      var start3 = ref3.start;
      var end = ref3.end;
      var name2 = ref3.name;
      if (this.inGenerator && name2 === "yield") {
        this.raiseRecoverable(start3, "Cannot use 'yield' as identifier inside a generator");
      }
      if (this.inAsync && name2 === "await") {
        this.raiseRecoverable(start3, "Cannot use 'await' as identifier inside an async function");
      }
      if (this.keywords.test(name2)) {
        this.raise(start3, "Unexpected keyword '" + name2 + "'");
      }
      if (this.options.ecmaVersion < 6 && this.input.slice(start3, end).indexOf("\\") !== -1) {
        return;
      }
      var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
      if (re.test(name2)) {
        if (!this.inAsync && name2 === "await") {
          this.raiseRecoverable(start3, "Cannot use keyword 'await' outside an async function");
        }
        this.raiseRecoverable(start3, "The keyword '" + name2 + "' is reserved");
      }
    };
    pp$32.parseIdent = function(liberal, isBinding) {
      var node2 = this.startNode();
      if (this.type === types2.name) {
        node2.name = this.value;
      } else if (this.type.keyword) {
        node2.name = this.type.keyword;
        if ((node2.name === "class" || node2.name === "function") && (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
          this.context.pop();
        }
      } else {
        this.unexpected();
      }
      this.next(!!liberal);
      this.finishNode(node2, "Identifier");
      if (!liberal) {
        this.checkUnreserved(node2);
        if (node2.name === "await" && !this.awaitIdentPos) {
          this.awaitIdentPos = node2.start;
        }
      }
      return node2;
    };
    pp$32.parseYield = function(noIn) {
      if (!this.yieldPos) {
        this.yieldPos = this.start;
      }
      var node2 = this.startNode();
      this.next();
      if (this.type === types2.semi || this.canInsertSemicolon() || this.type !== types2.star && !this.type.startsExpr) {
        node2.delegate = false;
        node2.argument = null;
      } else {
        node2.delegate = this.eat(types2.star);
        node2.argument = this.parseMaybeAssign(noIn);
      }
      return this.finishNode(node2, "YieldExpression");
    };
    pp$32.parseAwait = function() {
      if (!this.awaitPos) {
        this.awaitPos = this.start;
      }
      var node2 = this.startNode();
      this.next();
      node2.argument = this.parseMaybeUnary(null, false);
      return this.finishNode(node2, "AwaitExpression");
    };
    pp$42 = Parser3.prototype;
    pp$42.raise = function(pos2, message) {
      var loc = getLineInfo2(this.input, pos2);
      message += " (" + loc.line + ":" + loc.column + ")";
      var err = new SyntaxError(message);
      err.pos = pos2;
      err.loc = loc;
      err.raisedAt = this.pos;
      throw err;
    };
    pp$42.raiseRecoverable = pp$42.raise;
    pp$42.curPosition = function() {
      if (this.options.locations) {
        return new Position3(this.curLine, this.pos - this.lineStart);
      }
    };
    pp$52 = Parser3.prototype;
    Scope3 = function Scope4(flags) {
      this.flags = flags;
      this.var = [];
      this.lexical = [];
      this.functions = [];
    };
    pp$52.enterScope = function(flags) {
      this.scopeStack.push(new Scope3(flags));
    };
    pp$52.exitScope = function() {
      this.scopeStack.pop();
    };
    pp$52.treatFunctionsAsVarInScope = function(scope) {
      return scope.flags & SCOPE_FUNCTION2 || !this.inModule && scope.flags & SCOPE_TOP2;
    };
    pp$52.declareName = function(name2, bindingType, pos2) {
      var redeclared = false;
      if (bindingType === BIND_LEXICAL2) {
        var scope = this.currentScope();
        redeclared = scope.lexical.indexOf(name2) > -1 || scope.functions.indexOf(name2) > -1 || scope.var.indexOf(name2) > -1;
        scope.lexical.push(name2);
        if (this.inModule && scope.flags & SCOPE_TOP2) {
          delete this.undefinedExports[name2];
        }
      } else if (bindingType === BIND_SIMPLE_CATCH2) {
        var scope$1 = this.currentScope();
        scope$1.lexical.push(name2);
      } else if (bindingType === BIND_FUNCTION2) {
        var scope$2 = this.currentScope();
        if (this.treatFunctionsAsVar) {
          redeclared = scope$2.lexical.indexOf(name2) > -1;
        } else {
          redeclared = scope$2.lexical.indexOf(name2) > -1 || scope$2.var.indexOf(name2) > -1;
        }
        scope$2.functions.push(name2);
      } else {
        for (var i = this.scopeStack.length - 1; i >= 0; --i) {
          var scope$3 = this.scopeStack[i];
          if (scope$3.lexical.indexOf(name2) > -1 && !(scope$3.flags & SCOPE_SIMPLE_CATCH2 && scope$3.lexical[0] === name2) || !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name2) > -1) {
            redeclared = true;
            break;
          }
          scope$3.var.push(name2);
          if (this.inModule && scope$3.flags & SCOPE_TOP2) {
            delete this.undefinedExports[name2];
          }
          if (scope$3.flags & SCOPE_VAR2) {
            break;
          }
        }
      }
      if (redeclared) {
        this.raiseRecoverable(pos2, "Identifier '" + name2 + "' has already been declared");
      }
    };
    pp$52.checkLocalExport = function(id) {
      if (this.scopeStack[0].lexical.indexOf(id.name) === -1 && this.scopeStack[0].var.indexOf(id.name) === -1) {
        this.undefinedExports[id.name] = id;
      }
    };
    pp$52.currentScope = function() {
      return this.scopeStack[this.scopeStack.length - 1];
    };
    pp$52.currentVarScope = function() {
      for (var i = this.scopeStack.length - 1; ; i--) {
        var scope = this.scopeStack[i];
        if (scope.flags & SCOPE_VAR2) {
          return scope;
        }
      }
    };
    pp$52.currentThisScope = function() {
      for (var i = this.scopeStack.length - 1; ; i--) {
        var scope = this.scopeStack[i];
        if (scope.flags & SCOPE_VAR2 && !(scope.flags & SCOPE_ARROW2)) {
          return scope;
        }
      }
    };
    Node3 = function Node4(parser, pos2, loc) {
      this.type = "";
      this.start = pos2;
      this.end = 0;
      if (parser.options.locations) {
        this.loc = new SourceLocation3(parser, loc);
      }
      if (parser.options.directSourceFile) {
        this.sourceFile = parser.options.directSourceFile;
      }
      if (parser.options.ranges) {
        this.range = [pos2, 0];
      }
    };
    pp$62 = Parser3.prototype;
    pp$62.startNode = function() {
      return new Node3(this, this.start, this.startLoc);
    };
    pp$62.startNodeAt = function(pos2, loc) {
      return new Node3(this, pos2, loc);
    };
    pp$62.finishNode = function(node2, type) {
      return finishNodeAt2.call(this, node2, type, this.lastTokEnd, this.lastTokEndLoc);
    };
    pp$62.finishNodeAt = function(node2, type, pos2, loc) {
      return finishNodeAt2.call(this, node2, type, pos2, loc);
    };
    TokContext3 = function TokContext4(token2, isExpr, preserveSpace, override, generator) {
      this.token = token2;
      this.isExpr = !!isExpr;
      this.preserveSpace = !!preserveSpace;
      this.override = override;
      this.generator = !!generator;
    };
    types$12 = {
      b_stat: new TokContext3("{", false),
      b_expr: new TokContext3("{", true),
      b_tmpl: new TokContext3("${", false),
      p_stat: new TokContext3("(", false),
      p_expr: new TokContext3("(", true),
      q_tmpl: new TokContext3("`", true, true, function(p) {
        return p.tryReadTemplateToken();
      }),
      f_stat: new TokContext3("function", false),
      f_expr: new TokContext3("function", true),
      f_expr_gen: new TokContext3("function", true, false, null, true),
      f_gen: new TokContext3("function", false, false, null, true)
    };
    pp$72 = Parser3.prototype;
    pp$72.initialContext = function() {
      return [types$12.b_stat];
    };
    pp$72.braceIsBlock = function(prevType) {
      var parent = this.curContext();
      if (parent === types$12.f_expr || parent === types$12.f_stat) {
        return true;
      }
      if (prevType === types2.colon && (parent === types$12.b_stat || parent === types$12.b_expr)) {
        return !parent.isExpr;
      }
      if (prevType === types2._return || prevType === types2.name && this.exprAllowed) {
        return lineBreak2.test(this.input.slice(this.lastTokEnd, this.start));
      }
      if (prevType === types2._else || prevType === types2.semi || prevType === types2.eof || prevType === types2.parenR || prevType === types2.arrow) {
        return true;
      }
      if (prevType === types2.braceL) {
        return parent === types$12.b_stat;
      }
      if (prevType === types2._var || prevType === types2._const || prevType === types2.name) {
        return false;
      }
      return !this.exprAllowed;
    };
    pp$72.inGeneratorContext = function() {
      for (var i = this.context.length - 1; i >= 1; i--) {
        var context = this.context[i];
        if (context.token === "function") {
          return context.generator;
        }
      }
      return false;
    };
    pp$72.updateContext = function(prevType) {
      var update, type = this.type;
      if (type.keyword && prevType === types2.dot) {
        this.exprAllowed = false;
      } else if (update = type.updateContext) {
        update.call(this, prevType);
      } else {
        this.exprAllowed = type.beforeExpr;
      }
    };
    types2.parenR.updateContext = types2.braceR.updateContext = function() {
      if (this.context.length === 1) {
        this.exprAllowed = true;
        return;
      }
      var out = this.context.pop();
      if (out === types$12.b_stat && this.curContext().token === "function") {
        out = this.context.pop();
      }
      this.exprAllowed = !out.isExpr;
    };
    types2.braceL.updateContext = function(prevType) {
      this.context.push(this.braceIsBlock(prevType) ? types$12.b_stat : types$12.b_expr);
      this.exprAllowed = true;
    };
    types2.dollarBraceL.updateContext = function() {
      this.context.push(types$12.b_tmpl);
      this.exprAllowed = true;
    };
    types2.parenL.updateContext = function(prevType) {
      var statementParens = prevType === types2._if || prevType === types2._for || prevType === types2._with || prevType === types2._while;
      this.context.push(statementParens ? types$12.p_stat : types$12.p_expr);
      this.exprAllowed = true;
    };
    types2.incDec.updateContext = function() {
    };
    types2._function.updateContext = types2._class.updateContext = function(prevType) {
      if (prevType.beforeExpr && prevType !== types2.semi && prevType !== types2._else && !(prevType === types2._return && lineBreak2.test(this.input.slice(this.lastTokEnd, this.start))) && !((prevType === types2.colon || prevType === types2.braceL) && this.curContext() === types$12.b_stat)) {
        this.context.push(types$12.f_expr);
      } else {
        this.context.push(types$12.f_stat);
      }
      this.exprAllowed = false;
    };
    types2.backQuote.updateContext = function() {
      if (this.curContext() === types$12.q_tmpl) {
        this.context.pop();
      } else {
        this.context.push(types$12.q_tmpl);
      }
      this.exprAllowed = false;
    };
    types2.star.updateContext = function(prevType) {
      if (prevType === types2._function) {
        var index2 = this.context.length - 1;
        if (this.context[index2] === types$12.f_expr) {
          this.context[index2] = types$12.f_expr_gen;
        } else {
          this.context[index2] = types$12.f_gen;
        }
      }
      this.exprAllowed = true;
    };
    types2.name.updateContext = function(prevType) {
      var allowed = false;
      if (this.options.ecmaVersion >= 6 && prevType !== types2.dot) {
        if (this.value === "of" && !this.exprAllowed || this.value === "yield" && this.inGeneratorContext()) {
          allowed = true;
        }
      }
      this.exprAllowed = allowed;
    };
    ecma9BinaryProperties2 = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
    ecma10BinaryProperties2 = ecma9BinaryProperties2 + " Extended_Pictographic";
    ecma11BinaryProperties2 = ecma10BinaryProperties2;
    unicodeBinaryProperties2 = {
      9: ecma9BinaryProperties2,
      10: ecma10BinaryProperties2,
      11: ecma11BinaryProperties2
    };
    unicodeGeneralCategoryValues2 = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu";
    ecma9ScriptValues2 = "Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
    ecma10ScriptValues2 = ecma9ScriptValues2 + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
    ecma11ScriptValues2 = ecma10ScriptValues2 + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
    unicodeScriptValues2 = {
      9: ecma9ScriptValues2,
      10: ecma10ScriptValues2,
      11: ecma11ScriptValues2
    };
    data2 = {};
    buildUnicodeData2(9);
    buildUnicodeData2(10);
    buildUnicodeData2(11);
    pp$82 = Parser3.prototype;
    RegExpValidationState3 = function RegExpValidationState4(parser) {
      this.parser = parser;
      this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
      this.unicodeProperties = data2[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];
      this.source = "";
      this.flags = "";
      this.start = 0;
      this.switchU = false;
      this.switchN = false;
      this.pos = 0;
      this.lastIntValue = 0;
      this.lastStringValue = "";
      this.lastAssertionIsQuantifiable = false;
      this.numCapturingParens = 0;
      this.maxBackReference = 0;
      this.groupNames = [];
      this.backReferenceNames = [];
    };
    RegExpValidationState3.prototype.reset = function reset2(start3, pattern, flags) {
      var unicode2 = flags.indexOf("u") !== -1;
      this.start = start3 | 0;
      this.source = pattern + "";
      this.flags = flags;
      this.switchU = unicode2 && this.parser.options.ecmaVersion >= 6;
      this.switchN = unicode2 && this.parser.options.ecmaVersion >= 9;
    };
    RegExpValidationState3.prototype.raise = function raise2(message) {
      this.parser.raiseRecoverable(this.start, "Invalid regular expression: /" + this.source + "/: " + message);
    };
    RegExpValidationState3.prototype.at = function at2(i, forceU) {
      if (forceU === void 0)
        forceU = false;
      var s = this.source;
      var l = s.length;
      if (i >= l) {
        return -1;
      }
      var c2 = s.charCodeAt(i);
      if (!(forceU || this.switchU) || c2 <= 55295 || c2 >= 57344 || i + 1 >= l) {
        return c2;
      }
      var next = s.charCodeAt(i + 1);
      return next >= 56320 && next <= 57343 ? (c2 << 10) + next - 56613888 : c2;
    };
    RegExpValidationState3.prototype.nextIndex = function nextIndex2(i, forceU) {
      if (forceU === void 0)
        forceU = false;
      var s = this.source;
      var l = s.length;
      if (i >= l) {
        return l;
      }
      var c2 = s.charCodeAt(i), next;
      if (!(forceU || this.switchU) || c2 <= 55295 || c2 >= 57344 || i + 1 >= l || (next = s.charCodeAt(i + 1)) < 56320 || next > 57343) {
        return i + 1;
      }
      return i + 2;
    };
    RegExpValidationState3.prototype.current = function current2(forceU) {
      if (forceU === void 0)
        forceU = false;
      return this.at(this.pos, forceU);
    };
    RegExpValidationState3.prototype.lookahead = function lookahead2(forceU) {
      if (forceU === void 0)
        forceU = false;
      return this.at(this.nextIndex(this.pos, forceU), forceU);
    };
    RegExpValidationState3.prototype.advance = function advance2(forceU) {
      if (forceU === void 0)
        forceU = false;
      this.pos = this.nextIndex(this.pos, forceU);
    };
    RegExpValidationState3.prototype.eat = function eat2(ch, forceU) {
      if (forceU === void 0)
        forceU = false;
      if (this.current(forceU) === ch) {
        this.advance(forceU);
        return true;
      }
      return false;
    };
    pp$82.validateRegExpFlags = function(state) {
      var validFlags = state.validFlags;
      var flags = state.flags;
      for (var i = 0; i < flags.length; i++) {
        var flag = flags.charAt(i);
        if (validFlags.indexOf(flag) === -1) {
          this.raise(state.start, "Invalid regular expression flag");
        }
        if (flags.indexOf(flag, i + 1) > -1) {
          this.raise(state.start, "Duplicate regular expression flag");
        }
      }
    };
    pp$82.validateRegExpPattern = function(state) {
      this.regexp_pattern(state);
      if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
        state.switchN = true;
        this.regexp_pattern(state);
      }
    };
    pp$82.regexp_pattern = function(state) {
      state.pos = 0;
      state.lastIntValue = 0;
      state.lastStringValue = "";
      state.lastAssertionIsQuantifiable = false;
      state.numCapturingParens = 0;
      state.maxBackReference = 0;
      state.groupNames.length = 0;
      state.backReferenceNames.length = 0;
      this.regexp_disjunction(state);
      if (state.pos !== state.source.length) {
        if (state.eat(
          41
          /* ) */
        )) {
          state.raise("Unmatched ')'");
        }
        if (state.eat(
          93
          /* ] */
        ) || state.eat(
          125
          /* } */
        )) {
          state.raise("Lone quantifier brackets");
        }
      }
      if (state.maxBackReference > state.numCapturingParens) {
        state.raise("Invalid escape");
      }
      for (var i = 0, list3 = state.backReferenceNames; i < list3.length; i += 1) {
        var name2 = list3[i];
        if (state.groupNames.indexOf(name2) === -1) {
          state.raise("Invalid named capture referenced");
        }
      }
    };
    pp$82.regexp_disjunction = function(state) {
      this.regexp_alternative(state);
      while (state.eat(
        124
        /* | */
      )) {
        this.regexp_alternative(state);
      }
      if (this.regexp_eatQuantifier(state, true)) {
        state.raise("Nothing to repeat");
      }
      if (state.eat(
        123
        /* { */
      )) {
        state.raise("Lone quantifier brackets");
      }
    };
    pp$82.regexp_alternative = function(state) {
      while (state.pos < state.source.length && this.regexp_eatTerm(state)) {
      }
    };
    pp$82.regexp_eatTerm = function(state) {
      if (this.regexp_eatAssertion(state)) {
        if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
          if (state.switchU) {
            state.raise("Invalid quantifier");
          }
        }
        return true;
      }
      if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
        this.regexp_eatQuantifier(state);
        return true;
      }
      return false;
    };
    pp$82.regexp_eatAssertion = function(state) {
      var start3 = state.pos;
      state.lastAssertionIsQuantifiable = false;
      if (state.eat(
        94
        /* ^ */
      ) || state.eat(
        36
        /* $ */
      )) {
        return true;
      }
      if (state.eat(
        92
        /* \ */
      )) {
        if (state.eat(
          66
          /* B */
        ) || state.eat(
          98
          /* b */
        )) {
          return true;
        }
        state.pos = start3;
      }
      if (state.eat(
        40
        /* ( */
      ) && state.eat(
        63
        /* ? */
      )) {
        var lookbehind = false;
        if (this.options.ecmaVersion >= 9) {
          lookbehind = state.eat(
            60
            /* < */
          );
        }
        if (state.eat(
          61
          /* = */
        ) || state.eat(
          33
          /* ! */
        )) {
          this.regexp_disjunction(state);
          if (!state.eat(
            41
            /* ) */
          )) {
            state.raise("Unterminated group");
          }
          state.lastAssertionIsQuantifiable = !lookbehind;
          return true;
        }
      }
      state.pos = start3;
      return false;
    };
    pp$82.regexp_eatQuantifier = function(state, noError) {
      if (noError === void 0)
        noError = false;
      if (this.regexp_eatQuantifierPrefix(state, noError)) {
        state.eat(
          63
          /* ? */
        );
        return true;
      }
      return false;
    };
    pp$82.regexp_eatQuantifierPrefix = function(state, noError) {
      return state.eat(
        42
        /* * */
      ) || state.eat(
        43
        /* + */
      ) || state.eat(
        63
        /* ? */
      ) || this.regexp_eatBracedQuantifier(state, noError);
    };
    pp$82.regexp_eatBracedQuantifier = function(state, noError) {
      var start3 = state.pos;
      if (state.eat(
        123
        /* { */
      )) {
        var min = 0, max = -1;
        if (this.regexp_eatDecimalDigits(state)) {
          min = state.lastIntValue;
          if (state.eat(
            44
            /* , */
          ) && this.regexp_eatDecimalDigits(state)) {
            max = state.lastIntValue;
          }
          if (state.eat(
            125
            /* } */
          )) {
            if (max !== -1 && max < min && !noError) {
              state.raise("numbers out of order in {} quantifier");
            }
            return true;
          }
        }
        if (state.switchU && !noError) {
          state.raise("Incomplete quantifier");
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatAtom = function(state) {
      return this.regexp_eatPatternCharacters(state) || state.eat(
        46
        /* . */
      ) || this.regexp_eatReverseSolidusAtomEscape(state) || this.regexp_eatCharacterClass(state) || this.regexp_eatUncapturingGroup(state) || this.regexp_eatCapturingGroup(state);
    };
    pp$82.regexp_eatReverseSolidusAtomEscape = function(state) {
      var start3 = state.pos;
      if (state.eat(
        92
        /* \ */
      )) {
        if (this.regexp_eatAtomEscape(state)) {
          return true;
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatUncapturingGroup = function(state) {
      var start3 = state.pos;
      if (state.eat(
        40
        /* ( */
      )) {
        if (state.eat(
          63
          /* ? */
        ) && state.eat(
          58
          /* : */
        )) {
          this.regexp_disjunction(state);
          if (state.eat(
            41
            /* ) */
          )) {
            return true;
          }
          state.raise("Unterminated group");
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatCapturingGroup = function(state) {
      if (state.eat(
        40
        /* ( */
      )) {
        if (this.options.ecmaVersion >= 9) {
          this.regexp_groupSpecifier(state);
        } else if (state.current() === 63) {
          state.raise("Invalid group");
        }
        this.regexp_disjunction(state);
        if (state.eat(
          41
          /* ) */
        )) {
          state.numCapturingParens += 1;
          return true;
        }
        state.raise("Unterminated group");
      }
      return false;
    };
    pp$82.regexp_eatExtendedAtom = function(state) {
      return state.eat(
        46
        /* . */
      ) || this.regexp_eatReverseSolidusAtomEscape(state) || this.regexp_eatCharacterClass(state) || this.regexp_eatUncapturingGroup(state) || this.regexp_eatCapturingGroup(state) || this.regexp_eatInvalidBracedQuantifier(state) || this.regexp_eatExtendedPatternCharacter(state);
    };
    pp$82.regexp_eatInvalidBracedQuantifier = function(state) {
      if (this.regexp_eatBracedQuantifier(state, true)) {
        state.raise("Nothing to repeat");
      }
      return false;
    };
    pp$82.regexp_eatSyntaxCharacter = function(state) {
      var ch = state.current();
      if (isSyntaxCharacter2(ch)) {
        state.lastIntValue = ch;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatPatternCharacters = function(state) {
      var start3 = state.pos;
      var ch = 0;
      while ((ch = state.current()) !== -1 && !isSyntaxCharacter2(ch)) {
        state.advance();
      }
      return state.pos !== start3;
    };
    pp$82.regexp_eatExtendedPatternCharacter = function(state) {
      var ch = state.current();
      if (ch !== -1 && ch !== 36 && !(ch >= 40 && ch <= 43) && ch !== 46 && ch !== 63 && ch !== 91 && ch !== 94 && ch !== 124) {
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_groupSpecifier = function(state) {
      if (state.eat(
        63
        /* ? */
      )) {
        if (this.regexp_eatGroupName(state)) {
          if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
            state.raise("Duplicate capture group name");
          }
          state.groupNames.push(state.lastStringValue);
          return;
        }
        state.raise("Invalid group");
      }
    };
    pp$82.regexp_eatGroupName = function(state) {
      state.lastStringValue = "";
      if (state.eat(
        60
        /* < */
      )) {
        if (this.regexp_eatRegExpIdentifierName(state) && state.eat(
          62
          /* > */
        )) {
          return true;
        }
        state.raise("Invalid capture group name");
      }
      return false;
    };
    pp$82.regexp_eatRegExpIdentifierName = function(state) {
      state.lastStringValue = "";
      if (this.regexp_eatRegExpIdentifierStart(state)) {
        state.lastStringValue += codePointToString2(state.lastIntValue);
        while (this.regexp_eatRegExpIdentifierPart(state)) {
          state.lastStringValue += codePointToString2(state.lastIntValue);
        }
        return true;
      }
      return false;
    };
    pp$82.regexp_eatRegExpIdentifierStart = function(state) {
      var start3 = state.pos;
      var forceU = this.options.ecmaVersion >= 11;
      var ch = state.current(forceU);
      state.advance(forceU);
      if (ch === 92 && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
        ch = state.lastIntValue;
      }
      if (isRegExpIdentifierStart2(ch)) {
        state.lastIntValue = ch;
        return true;
      }
      state.pos = start3;
      return false;
    };
    pp$82.regexp_eatRegExpIdentifierPart = function(state) {
      var start3 = state.pos;
      var forceU = this.options.ecmaVersion >= 11;
      var ch = state.current(forceU);
      state.advance(forceU);
      if (ch === 92 && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
        ch = state.lastIntValue;
      }
      if (isRegExpIdentifierPart2(ch)) {
        state.lastIntValue = ch;
        return true;
      }
      state.pos = start3;
      return false;
    };
    pp$82.regexp_eatAtomEscape = function(state) {
      if (this.regexp_eatBackReference(state) || this.regexp_eatCharacterClassEscape(state) || this.regexp_eatCharacterEscape(state) || state.switchN && this.regexp_eatKGroupName(state)) {
        return true;
      }
      if (state.switchU) {
        if (state.current() === 99) {
          state.raise("Invalid unicode escape");
        }
        state.raise("Invalid escape");
      }
      return false;
    };
    pp$82.regexp_eatBackReference = function(state) {
      var start3 = state.pos;
      if (this.regexp_eatDecimalEscape(state)) {
        var n = state.lastIntValue;
        if (state.switchU) {
          if (n > state.maxBackReference) {
            state.maxBackReference = n;
          }
          return true;
        }
        if (n <= state.numCapturingParens) {
          return true;
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatKGroupName = function(state) {
      if (state.eat(
        107
        /* k */
      )) {
        if (this.regexp_eatGroupName(state)) {
          state.backReferenceNames.push(state.lastStringValue);
          return true;
        }
        state.raise("Invalid named reference");
      }
      return false;
    };
    pp$82.regexp_eatCharacterEscape = function(state) {
      return this.regexp_eatControlEscape(state) || this.regexp_eatCControlLetter(state) || this.regexp_eatZero(state) || this.regexp_eatHexEscapeSequence(state) || this.regexp_eatRegExpUnicodeEscapeSequence(state, false) || !state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state) || this.regexp_eatIdentityEscape(state);
    };
    pp$82.regexp_eatCControlLetter = function(state) {
      var start3 = state.pos;
      if (state.eat(
        99
        /* c */
      )) {
        if (this.regexp_eatControlLetter(state)) {
          return true;
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatZero = function(state) {
      if (state.current() === 48 && !isDecimalDigit2(state.lookahead())) {
        state.lastIntValue = 0;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatControlEscape = function(state) {
      var ch = state.current();
      if (ch === 116) {
        state.lastIntValue = 9;
        state.advance();
        return true;
      }
      if (ch === 110) {
        state.lastIntValue = 10;
        state.advance();
        return true;
      }
      if (ch === 118) {
        state.lastIntValue = 11;
        state.advance();
        return true;
      }
      if (ch === 102) {
        state.lastIntValue = 12;
        state.advance();
        return true;
      }
      if (ch === 114) {
        state.lastIntValue = 13;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatControlLetter = function(state) {
      var ch = state.current();
      if (isControlLetter2(ch)) {
        state.lastIntValue = ch % 32;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {
      if (forceU === void 0)
        forceU = false;
      var start3 = state.pos;
      var switchU = forceU || state.switchU;
      if (state.eat(
        117
        /* u */
      )) {
        if (this.regexp_eatFixedHexDigits(state, 4)) {
          var lead = state.lastIntValue;
          if (switchU && lead >= 55296 && lead <= 56319) {
            var leadSurrogateEnd = state.pos;
            if (state.eat(
              92
              /* \ */
            ) && state.eat(
              117
              /* u */
            ) && this.regexp_eatFixedHexDigits(state, 4)) {
              var trail = state.lastIntValue;
              if (trail >= 56320 && trail <= 57343) {
                state.lastIntValue = (lead - 55296) * 1024 + (trail - 56320) + 65536;
                return true;
              }
            }
            state.pos = leadSurrogateEnd;
            state.lastIntValue = lead;
          }
          return true;
        }
        if (switchU && state.eat(
          123
          /* { */
        ) && this.regexp_eatHexDigits(state) && state.eat(
          125
          /* } */
        ) && isValidUnicode2(state.lastIntValue)) {
          return true;
        }
        if (switchU) {
          state.raise("Invalid unicode escape");
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatIdentityEscape = function(state) {
      if (state.switchU) {
        if (this.regexp_eatSyntaxCharacter(state)) {
          return true;
        }
        if (state.eat(
          47
          /* / */
        )) {
          state.lastIntValue = 47;
          return true;
        }
        return false;
      }
      var ch = state.current();
      if (ch !== 99 && (!state.switchN || ch !== 107)) {
        state.lastIntValue = ch;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatDecimalEscape = function(state) {
      state.lastIntValue = 0;
      var ch = state.current();
      if (ch >= 49 && ch <= 57) {
        do {
          state.lastIntValue = 10 * state.lastIntValue + (ch - 48);
          state.advance();
        } while ((ch = state.current()) >= 48 && ch <= 57);
        return true;
      }
      return false;
    };
    pp$82.regexp_eatCharacterClassEscape = function(state) {
      var ch = state.current();
      if (isCharacterClassEscape2(ch)) {
        state.lastIntValue = -1;
        state.advance();
        return true;
      }
      if (state.switchU && this.options.ecmaVersion >= 9 && (ch === 80 || ch === 112)) {
        state.lastIntValue = -1;
        state.advance();
        if (state.eat(
          123
          /* { */
        ) && this.regexp_eatUnicodePropertyValueExpression(state) && state.eat(
          125
          /* } */
        )) {
          return true;
        }
        state.raise("Invalid property name");
      }
      return false;
    };
    pp$82.regexp_eatUnicodePropertyValueExpression = function(state) {
      var start3 = state.pos;
      if (this.regexp_eatUnicodePropertyName(state) && state.eat(
        61
        /* = */
      )) {
        var name2 = state.lastStringValue;
        if (this.regexp_eatUnicodePropertyValue(state)) {
          var value2 = state.lastStringValue;
          this.regexp_validateUnicodePropertyNameAndValue(state, name2, value2);
          return true;
        }
      }
      state.pos = start3;
      if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
        var nameOrValue = state.lastStringValue;
        this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
        return true;
      }
      return false;
    };
    pp$82.regexp_validateUnicodePropertyNameAndValue = function(state, name2, value2) {
      if (!has(state.unicodeProperties.nonBinary, name2)) {
        state.raise("Invalid property name");
      }
      if (!state.unicodeProperties.nonBinary[name2].test(value2)) {
        state.raise("Invalid property value");
      }
    };
    pp$82.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
      if (!state.unicodeProperties.binary.test(nameOrValue)) {
        state.raise("Invalid property name");
      }
    };
    pp$82.regexp_eatUnicodePropertyName = function(state) {
      var ch = 0;
      state.lastStringValue = "";
      while (isUnicodePropertyNameCharacter2(ch = state.current())) {
        state.lastStringValue += codePointToString2(ch);
        state.advance();
      }
      return state.lastStringValue !== "";
    };
    pp$82.regexp_eatUnicodePropertyValue = function(state) {
      var ch = 0;
      state.lastStringValue = "";
      while (isUnicodePropertyValueCharacter2(ch = state.current())) {
        state.lastStringValue += codePointToString2(ch);
        state.advance();
      }
      return state.lastStringValue !== "";
    };
    pp$82.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
      return this.regexp_eatUnicodePropertyValue(state);
    };
    pp$82.regexp_eatCharacterClass = function(state) {
      if (state.eat(
        91
        /* [ */
      )) {
        state.eat(
          94
          /* ^ */
        );
        this.regexp_classRanges(state);
        if (state.eat(
          93
          /* ] */
        )) {
          return true;
        }
        state.raise("Unterminated character class");
      }
      return false;
    };
    pp$82.regexp_classRanges = function(state) {
      while (this.regexp_eatClassAtom(state)) {
        var left = state.lastIntValue;
        if (state.eat(
          45
          /* - */
        ) && this.regexp_eatClassAtom(state)) {
          var right = state.lastIntValue;
          if (state.switchU && (left === -1 || right === -1)) {
            state.raise("Invalid character class");
          }
          if (left !== -1 && right !== -1 && left > right) {
            state.raise("Range out of order in character class");
          }
        }
      }
    };
    pp$82.regexp_eatClassAtom = function(state) {
      var start3 = state.pos;
      if (state.eat(
        92
        /* \ */
      )) {
        if (this.regexp_eatClassEscape(state)) {
          return true;
        }
        if (state.switchU) {
          var ch$1 = state.current();
          if (ch$1 === 99 || isOctalDigit2(ch$1)) {
            state.raise("Invalid class escape");
          }
          state.raise("Invalid escape");
        }
        state.pos = start3;
      }
      var ch = state.current();
      if (ch !== 93) {
        state.lastIntValue = ch;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatClassEscape = function(state) {
      var start3 = state.pos;
      if (state.eat(
        98
        /* b */
      )) {
        state.lastIntValue = 8;
        return true;
      }
      if (state.switchU && state.eat(
        45
        /* - */
      )) {
        state.lastIntValue = 45;
        return true;
      }
      if (!state.switchU && state.eat(
        99
        /* c */
      )) {
        if (this.regexp_eatClassControlLetter(state)) {
          return true;
        }
        state.pos = start3;
      }
      return this.regexp_eatCharacterClassEscape(state) || this.regexp_eatCharacterEscape(state);
    };
    pp$82.regexp_eatClassControlLetter = function(state) {
      var ch = state.current();
      if (isDecimalDigit2(ch) || ch === 95) {
        state.lastIntValue = ch % 32;
        state.advance();
        return true;
      }
      return false;
    };
    pp$82.regexp_eatHexEscapeSequence = function(state) {
      var start3 = state.pos;
      if (state.eat(
        120
        /* x */
      )) {
        if (this.regexp_eatFixedHexDigits(state, 2)) {
          return true;
        }
        if (state.switchU) {
          state.raise("Invalid escape");
        }
        state.pos = start3;
      }
      return false;
    };
    pp$82.regexp_eatDecimalDigits = function(state) {
      var start3 = state.pos;
      var ch = 0;
      state.lastIntValue = 0;
      while (isDecimalDigit2(ch = state.current())) {
        state.lastIntValue = 10 * state.lastIntValue + (ch - 48);
        state.advance();
      }
      return state.pos !== start3;
    };
    pp$82.regexp_eatHexDigits = function(state) {
      var start3 = state.pos;
      var ch = 0;
      state.lastIntValue = 0;
      while (isHexDigit2(ch = state.current())) {
        state.lastIntValue = 16 * state.lastIntValue + hexToInt2(ch);
        state.advance();
      }
      return state.pos !== start3;
    };
    pp$82.regexp_eatLegacyOctalEscapeSequence = function(state) {
      if (this.regexp_eatOctalDigit(state)) {
        var n1 = state.lastIntValue;
        if (this.regexp_eatOctalDigit(state)) {
          var n2 = state.lastIntValue;
          if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
            state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
          } else {
            state.lastIntValue = n1 * 8 + n2;
          }
        } else {
          state.lastIntValue = n1;
        }
        return true;
      }
      return false;
    };
    pp$82.regexp_eatOctalDigit = function(state) {
      var ch = state.current();
      if (isOctalDigit2(ch)) {
        state.lastIntValue = ch - 48;
        state.advance();
        return true;
      }
      state.lastIntValue = 0;
      return false;
    };
    pp$82.regexp_eatFixedHexDigits = function(state, length) {
      var start3 = state.pos;
      state.lastIntValue = 0;
      for (var i = 0; i < length; ++i) {
        var ch = state.current();
        if (!isHexDigit2(ch)) {
          state.pos = start3;
          return false;
        }
        state.lastIntValue = 16 * state.lastIntValue + hexToInt2(ch);
        state.advance();
      }
      return true;
    };
    Token3 = function Token4(p) {
      this.type = p.type;
      this.value = p.value;
      this.start = p.start;
      this.end = p.end;
      if (p.options.locations) {
        this.loc = new SourceLocation3(p, p.startLoc, p.endLoc);
      }
      if (p.options.ranges) {
        this.range = [p.start, p.end];
      }
    };
    pp$92 = Parser3.prototype;
    pp$92.next = function(ignoreEscapeSequenceInKeyword) {
      if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc) {
        this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword);
      }
      if (this.options.onToken) {
        this.options.onToken(new Token3(this));
      }
      this.lastTokEnd = this.end;
      this.lastTokStart = this.start;
      this.lastTokEndLoc = this.endLoc;
      this.lastTokStartLoc = this.startLoc;
      this.nextToken();
    };
    pp$92.getToken = function() {
      this.next();
      return new Token3(this);
    };
    if (typeof Symbol !== "undefined") {
      pp$92[Symbol.iterator] = function() {
        var this$1 = this;
        return {
          next: function() {
            var token2 = this$1.getToken();
            return {
              done: token2.type === types2.eof,
              value: token2
            };
          }
        };
      };
    }
    pp$92.curContext = function() {
      return this.context[this.context.length - 1];
    };
    pp$92.nextToken = function() {
      var curContext = this.curContext();
      if (!curContext || !curContext.preserveSpace) {
        this.skipSpace();
      }
      this.start = this.pos;
      if (this.options.locations) {
        this.startLoc = this.curPosition();
      }
      if (this.pos >= this.input.length) {
        return this.finishToken(types2.eof);
      }
      if (curContext.override) {
        return curContext.override(this);
      } else {
        this.readToken(this.fullCharCodeAtPos());
      }
    };
    pp$92.readToken = function(code2) {
      if (isIdentifierStart2(code2, this.options.ecmaVersion >= 6) || code2 === 92) {
        return this.readWord();
      }
      return this.getTokenFromCode(code2);
    };
    pp$92.fullCharCodeAtPos = function() {
      var code2 = this.input.charCodeAt(this.pos);
      if (code2 <= 55295 || code2 >= 57344) {
        return code2;
      }
      var next = this.input.charCodeAt(this.pos + 1);
      return (code2 << 10) + next - 56613888;
    };
    pp$92.skipBlockComment = function() {
      var startLoc = this.options.onComment && this.curPosition();
      var start3 = this.pos, end = this.input.indexOf("*/", this.pos += 2);
      if (end === -1) {
        this.raise(this.pos - 2, "Unterminated comment");
      }
      this.pos = end + 2;
      if (this.options.locations) {
        lineBreakG2.lastIndex = start3;
        var match;
        while ((match = lineBreakG2.exec(this.input)) && match.index < this.pos) {
          ++this.curLine;
          this.lineStart = match.index + match[0].length;
        }
      }
      if (this.options.onComment) {
        this.options.onComment(
          true,
          this.input.slice(start3 + 2, end),
          start3,
          this.pos,
          startLoc,
          this.curPosition()
        );
      }
    };
    pp$92.skipLineComment = function(startSkip) {
      var start3 = this.pos;
      var startLoc = this.options.onComment && this.curPosition();
      var ch = this.input.charCodeAt(this.pos += startSkip);
      while (this.pos < this.input.length && !isNewLine2(ch)) {
        ch = this.input.charCodeAt(++this.pos);
      }
      if (this.options.onComment) {
        this.options.onComment(
          false,
          this.input.slice(start3 + startSkip, this.pos),
          start3,
          this.pos,
          startLoc,
          this.curPosition()
        );
      }
    };
    pp$92.skipSpace = function() {
      loop:
        while (this.pos < this.input.length) {
          var ch = this.input.charCodeAt(this.pos);
          switch (ch) {
            case 32:
            case 160:
              ++this.pos;
              break;
            case 13:
              if (this.input.charCodeAt(this.pos + 1) === 10) {
                ++this.pos;
              }
            case 10:
            case 8232:
            case 8233:
              ++this.pos;
              if (this.options.locations) {
                ++this.curLine;
                this.lineStart = this.pos;
              }
              break;
            case 47:
              switch (this.input.charCodeAt(this.pos + 1)) {
                case 42:
                  this.skipBlockComment();
                  break;
                case 47:
                  this.skipLineComment(2);
                  break;
                default:
                  break loop;
              }
              break;
            default:
              if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace2.test(String.fromCharCode(ch))) {
                ++this.pos;
              } else {
                break loop;
              }
          }
        }
    };
    pp$92.finishToken = function(type, val) {
      this.end = this.pos;
      if (this.options.locations) {
        this.endLoc = this.curPosition();
      }
      var prevType = this.type;
      this.type = type;
      this.value = val;
      this.updateContext(prevType);
    };
    pp$92.readToken_dot = function() {
      var next = this.input.charCodeAt(this.pos + 1);
      if (next >= 48 && next <= 57) {
        return this.readNumber(true);
      }
      var next2 = this.input.charCodeAt(this.pos + 2);
      if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {
        this.pos += 3;
        return this.finishToken(types2.ellipsis);
      } else {
        ++this.pos;
        return this.finishToken(types2.dot);
      }
    };
    pp$92.readToken_slash = function() {
      var next = this.input.charCodeAt(this.pos + 1);
      if (this.exprAllowed) {
        ++this.pos;
        return this.readRegexp();
      }
      if (next === 61) {
        return this.finishOp(types2.assign, 2);
      }
      return this.finishOp(types2.slash, 1);
    };
    pp$92.readToken_mult_modulo_exp = function(code2) {
      var next = this.input.charCodeAt(this.pos + 1);
      var size = 1;
      var tokentype = code2 === 42 ? types2.star : types2.modulo;
      if (this.options.ecmaVersion >= 7 && code2 === 42 && next === 42) {
        ++size;
        tokentype = types2.starstar;
        next = this.input.charCodeAt(this.pos + 2);
      }
      if (next === 61) {
        return this.finishOp(types2.assign, size + 1);
      }
      return this.finishOp(tokentype, size);
    };
    pp$92.readToken_pipe_amp = function(code2) {
      var next = this.input.charCodeAt(this.pos + 1);
      if (next === code2) {
        if (this.options.ecmaVersion >= 12) {
          var next2 = this.input.charCodeAt(this.pos + 2);
          if (next2 === 61) {
            return this.finishOp(types2.assign, 3);
          }
        }
        return this.finishOp(code2 === 124 ? types2.logicalOR : types2.logicalAND, 2);
      }
      if (next === 61) {
        return this.finishOp(types2.assign, 2);
      }
      return this.finishOp(code2 === 124 ? types2.bitwiseOR : types2.bitwiseAND, 1);
    };
    pp$92.readToken_caret = function() {
      var next = this.input.charCodeAt(this.pos + 1);
      if (next === 61) {
        return this.finishOp(types2.assign, 2);
      }
      return this.finishOp(types2.bitwiseXOR, 1);
    };
    pp$92.readToken_plus_min = function(code2) {
      var next = this.input.charCodeAt(this.pos + 1);
      if (next === code2) {
        if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 && (this.lastTokEnd === 0 || lineBreak2.test(this.input.slice(this.lastTokEnd, this.pos)))) {
          this.skipLineComment(3);
          this.skipSpace();
          return this.nextToken();
        }
        return this.finishOp(types2.incDec, 2);
      }
      if (next === 61) {
        return this.finishOp(types2.assign, 2);
      }
      return this.finishOp(types2.plusMin, 1);
    };
    pp$92.readToken_lt_gt = function(code2) {
      var next = this.input.charCodeAt(this.pos + 1);
      var size = 1;
      if (next === code2) {
        size = code2 === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
        if (this.input.charCodeAt(this.pos + size) === 61) {
          return this.finishOp(types2.assign, size + 1);
        }
        return this.finishOp(types2.bitShift, size);
      }
      if (next === 33 && code2 === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 && this.input.charCodeAt(this.pos + 3) === 45) {
        this.skipLineComment(4);
        this.skipSpace();
        return this.nextToken();
      }
      if (next === 61) {
        size = 2;
      }
      return this.finishOp(types2.relational, size);
    };
    pp$92.readToken_eq_excl = function(code2) {
      var next = this.input.charCodeAt(this.pos + 1);
      if (next === 61) {
        return this.finishOp(types2.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
      }
      if (code2 === 61 && next === 62 && this.options.ecmaVersion >= 6) {
        this.pos += 2;
        return this.finishToken(types2.arrow);
      }
      return this.finishOp(code2 === 61 ? types2.eq : types2.prefix, 1);
    };
    pp$92.readToken_question = function() {
      var ecmaVersion = this.options.ecmaVersion;
      if (ecmaVersion >= 11) {
        var next = this.input.charCodeAt(this.pos + 1);
        if (next === 46) {
          var next2 = this.input.charCodeAt(this.pos + 2);
          if (next2 < 48 || next2 > 57) {
            return this.finishOp(types2.questionDot, 2);
          }
        }
        if (next === 63) {
          if (ecmaVersion >= 12) {
            var next2$1 = this.input.charCodeAt(this.pos + 2);
            if (next2$1 === 61) {
              return this.finishOp(types2.assign, 3);
            }
          }
          return this.finishOp(types2.coalesce, 2);
        }
      }
      return this.finishOp(types2.question, 1);
    };
    pp$92.getTokenFromCode = function(code2) {
      switch (code2) {
        case 46:
          return this.readToken_dot();
        case 40:
          ++this.pos;
          return this.finishToken(types2.parenL);
        case 41:
          ++this.pos;
          return this.finishToken(types2.parenR);
        case 59:
          ++this.pos;
          return this.finishToken(types2.semi);
        case 44:
          ++this.pos;
          return this.finishToken(types2.comma);
        case 91:
          ++this.pos;
          return this.finishToken(types2.bracketL);
        case 93:
          ++this.pos;
          return this.finishToken(types2.bracketR);
        case 123:
          ++this.pos;
          return this.finishToken(types2.braceL);
        case 125:
          ++this.pos;
          return this.finishToken(types2.braceR);
        case 58:
          ++this.pos;
          return this.finishToken(types2.colon);
        case 96:
          if (this.options.ecmaVersion < 6) {
            break;
          }
          ++this.pos;
          return this.finishToken(types2.backQuote);
        case 48:
          var next = this.input.charCodeAt(this.pos + 1);
          if (next === 120 || next === 88) {
            return this.readRadixNumber(16);
          }
          if (this.options.ecmaVersion >= 6) {
            if (next === 111 || next === 79) {
              return this.readRadixNumber(8);
            }
            if (next === 98 || next === 66) {
              return this.readRadixNumber(2);
            }
          }
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
          return this.readNumber(false);
        case 34:
        case 39:
          return this.readString(code2);
        case 47:
          return this.readToken_slash();
        case 37:
        case 42:
          return this.readToken_mult_modulo_exp(code2);
        case 124:
        case 38:
          return this.readToken_pipe_amp(code2);
        case 94:
          return this.readToken_caret();
        case 43:
        case 45:
          return this.readToken_plus_min(code2);
        case 60:
        case 62:
          return this.readToken_lt_gt(code2);
        case 61:
        case 33:
          return this.readToken_eq_excl(code2);
        case 63:
          return this.readToken_question();
        case 126:
          return this.finishOp(types2.prefix, 1);
      }
      this.raise(this.pos, "Unexpected character '" + codePointToString$1(code2) + "'");
    };
    pp$92.finishOp = function(type, size) {
      var str = this.input.slice(this.pos, this.pos + size);
      this.pos += size;
      return this.finishToken(type, str);
    };
    pp$92.readRegexp = function() {
      var escaped, inClass, start3 = this.pos;
      for (; ; ) {
        if (this.pos >= this.input.length) {
          this.raise(start3, "Unterminated regular expression");
        }
        var ch = this.input.charAt(this.pos);
        if (lineBreak2.test(ch)) {
          this.raise(start3, "Unterminated regular expression");
        }
        if (!escaped) {
          if (ch === "[") {
            inClass = true;
          } else if (ch === "]" && inClass) {
            inClass = false;
          } else if (ch === "/" && !inClass) {
            break;
          }
          escaped = ch === "\\";
        } else {
          escaped = false;
        }
        ++this.pos;
      }
      var pattern = this.input.slice(start3, this.pos);
      ++this.pos;
      var flagsStart = this.pos;
      var flags = this.readWord1();
      if (this.containsEsc) {
        this.unexpected(flagsStart);
      }
      var state = this.regexpState || (this.regexpState = new RegExpValidationState3(this));
      state.reset(start3, pattern, flags);
      this.validateRegExpFlags(state);
      this.validateRegExpPattern(state);
      var value2 = null;
      try {
        value2 = new RegExp(pattern, flags);
      } catch (e) {
      }
      return this.finishToken(types2.regexp, { pattern, flags, value: value2 });
    };
    pp$92.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
      var allowSeparators = this.options.ecmaVersion >= 12 && len === void 0;
      var isLegacyOctalNumericLiteral = maybeLegacyOctalNumericLiteral && this.input.charCodeAt(this.pos) === 48;
      var start3 = this.pos, total = 0, lastCode = 0;
      for (var i = 0, e = len == null ? Infinity : len; i < e; ++i, ++this.pos) {
        var code2 = this.input.charCodeAt(this.pos), val = void 0;
        if (allowSeparators && code2 === 95) {
          if (isLegacyOctalNumericLiteral) {
            this.raiseRecoverable(this.pos, "Numeric separator is not allowed in legacy octal numeric literals");
          }
          if (lastCode === 95) {
            this.raiseRecoverable(this.pos, "Numeric separator must be exactly one underscore");
          }
          if (i === 0) {
            this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits");
          }
          lastCode = code2;
          continue;
        }
        if (code2 >= 97) {
          val = code2 - 97 + 10;
        } else if (code2 >= 65) {
          val = code2 - 65 + 10;
        } else if (code2 >= 48 && code2 <= 57) {
          val = code2 - 48;
        } else {
          val = Infinity;
        }
        if (val >= radix) {
          break;
        }
        lastCode = code2;
        total = total * radix + val;
      }
      if (allowSeparators && lastCode === 95) {
        this.raiseRecoverable(this.pos - 1, "Numeric separator is not allowed at the last of digits");
      }
      if (this.pos === start3 || len != null && this.pos - start3 !== len) {
        return null;
      }
      return total;
    };
    pp$92.readRadixNumber = function(radix) {
      var start3 = this.pos;
      this.pos += 2;
      var val = this.readInt(radix);
      if (val == null) {
        this.raise(this.start + 2, "Expected number in radix " + radix);
      }
      if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
        val = stringToBigInt2(this.input.slice(start3, this.pos));
        ++this.pos;
      } else if (isIdentifierStart2(this.fullCharCodeAtPos())) {
        this.raise(this.pos, "Identifier directly after number");
      }
      return this.finishToken(types2.num, val);
    };
    pp$92.readNumber = function(startsWithDot) {
      var start3 = this.pos;
      if (!startsWithDot && this.readInt(10, void 0, true) === null) {
        this.raise(start3, "Invalid number");
      }
      var octal = this.pos - start3 >= 2 && this.input.charCodeAt(start3) === 48;
      if (octal && this.strict) {
        this.raise(start3, "Invalid number");
      }
      var next = this.input.charCodeAt(this.pos);
      if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
        var val$1 = stringToBigInt2(this.input.slice(start3, this.pos));
        ++this.pos;
        if (isIdentifierStart2(this.fullCharCodeAtPos())) {
          this.raise(this.pos, "Identifier directly after number");
        }
        return this.finishToken(types2.num, val$1);
      }
      if (octal && /[89]/.test(this.input.slice(start3, this.pos))) {
        octal = false;
      }
      if (next === 46 && !octal) {
        ++this.pos;
        this.readInt(10);
        next = this.input.charCodeAt(this.pos);
      }
      if ((next === 69 || next === 101) && !octal) {
        next = this.input.charCodeAt(++this.pos);
        if (next === 43 || next === 45) {
          ++this.pos;
        }
        if (this.readInt(10) === null) {
          this.raise(start3, "Invalid number");
        }
      }
      if (isIdentifierStart2(this.fullCharCodeAtPos())) {
        this.raise(this.pos, "Identifier directly after number");
      }
      var val = stringToNumber2(this.input.slice(start3, this.pos), octal);
      return this.finishToken(types2.num, val);
    };
    pp$92.readCodePoint = function() {
      var ch = this.input.charCodeAt(this.pos), code2;
      if (ch === 123) {
        if (this.options.ecmaVersion < 6) {
          this.unexpected();
        }
        var codePos = ++this.pos;
        code2 = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
        ++this.pos;
        if (code2 > 1114111) {
          this.invalidStringToken(codePos, "Code point out of bounds");
        }
      } else {
        code2 = this.readHexChar(4);
      }
      return code2;
    };
    pp$92.readString = function(quote) {
      var out = "", chunkStart = ++this.pos;
      for (; ; ) {
        if (this.pos >= this.input.length) {
          this.raise(this.start, "Unterminated string constant");
        }
        var ch = this.input.charCodeAt(this.pos);
        if (ch === quote) {
          break;
        }
        if (ch === 92) {
          out += this.input.slice(chunkStart, this.pos);
          out += this.readEscapedChar(false);
          chunkStart = this.pos;
        } else {
          if (isNewLine2(ch, this.options.ecmaVersion >= 10)) {
            this.raise(this.start, "Unterminated string constant");
          }
          ++this.pos;
        }
      }
      out += this.input.slice(chunkStart, this.pos++);
      return this.finishToken(types2.string, out);
    };
    INVALID_TEMPLATE_ESCAPE_ERROR2 = {};
    pp$92.tryReadTemplateToken = function() {
      this.inTemplateElement = true;
      try {
        this.readTmplToken();
      } catch (err) {
        if (err === INVALID_TEMPLATE_ESCAPE_ERROR2) {
          this.readInvalidTemplateToken();
        } else {
          throw err;
        }
      }
      this.inTemplateElement = false;
    };
    pp$92.invalidStringToken = function(position3, message) {
      if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
        throw INVALID_TEMPLATE_ESCAPE_ERROR2;
      } else {
        this.raise(position3, message);
      }
    };
    pp$92.readTmplToken = function() {
      var out = "", chunkStart = this.pos;
      for (; ; ) {
        if (this.pos >= this.input.length) {
          this.raise(this.start, "Unterminated template");
        }
        var ch = this.input.charCodeAt(this.pos);
        if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) {
          if (this.pos === this.start && (this.type === types2.template || this.type === types2.invalidTemplate)) {
            if (ch === 36) {
              this.pos += 2;
              return this.finishToken(types2.dollarBraceL);
            } else {
              ++this.pos;
              return this.finishToken(types2.backQuote);
            }
          }
          out += this.input.slice(chunkStart, this.pos);
          return this.finishToken(types2.template, out);
        }
        if (ch === 92) {
          out += this.input.slice(chunkStart, this.pos);
          out += this.readEscapedChar(true);
          chunkStart = this.pos;
        } else if (isNewLine2(ch)) {
          out += this.input.slice(chunkStart, this.pos);
          ++this.pos;
          switch (ch) {
            case 13:
              if (this.input.charCodeAt(this.pos) === 10) {
                ++this.pos;
              }
            case 10:
              out += "\n";
              break;
            default:
              out += String.fromCharCode(ch);
              break;
          }
          if (this.options.locations) {
            ++this.curLine;
            this.lineStart = this.pos;
          }
          chunkStart = this.pos;
        } else {
          ++this.pos;
        }
      }
    };
    pp$92.readInvalidTemplateToken = function() {
      for (; this.pos < this.input.length; this.pos++) {
        switch (this.input[this.pos]) {
          case "\\":
            ++this.pos;
            break;
          case "$":
            if (this.input[this.pos + 1] !== "{") {
              break;
            }
          case "`":
            return this.finishToken(types2.invalidTemplate, this.input.slice(this.start, this.pos));
        }
      }
      this.raise(this.start, "Unterminated template");
    };
    pp$92.readEscapedChar = function(inTemplate) {
      var ch = this.input.charCodeAt(++this.pos);
      ++this.pos;
      switch (ch) {
        case 110:
          return "\n";
        case 114:
          return "\r";
        case 120:
          return String.fromCharCode(this.readHexChar(2));
        case 117:
          return codePointToString$1(this.readCodePoint());
        case 116:
          return "	";
        case 98:
          return "\b";
        case 118:
          return "\v";
        case 102:
          return "\f";
        case 13:
          if (this.input.charCodeAt(this.pos) === 10) {
            ++this.pos;
          }
        case 10:
          if (this.options.locations) {
            this.lineStart = this.pos;
            ++this.curLine;
          }
          return "";
        case 56:
        case 57:
          if (inTemplate) {
            var codePos = this.pos - 1;
            this.invalidStringToken(
              codePos,
              "Invalid escape sequence in template string"
            );
            return null;
          }
        default:
          if (ch >= 48 && ch <= 55) {
            var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
            var octal = parseInt(octalStr, 8);
            if (octal > 255) {
              octalStr = octalStr.slice(0, -1);
              octal = parseInt(octalStr, 8);
            }
            this.pos += octalStr.length - 1;
            ch = this.input.charCodeAt(this.pos);
            if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
              this.invalidStringToken(
                this.pos - 1 - octalStr.length,
                inTemplate ? "Octal literal in template string" : "Octal literal in strict mode"
              );
            }
            return String.fromCharCode(octal);
          }
          if (isNewLine2(ch)) {
            return "";
          }
          return String.fromCharCode(ch);
      }
    };
    pp$92.readHexChar = function(len) {
      var codePos = this.pos;
      var n = this.readInt(16, len);
      if (n === null) {
        this.invalidStringToken(codePos, "Bad character escape sequence");
      }
      return n;
    };
    pp$92.readWord1 = function() {
      this.containsEsc = false;
      var word = "", first = true, chunkStart = this.pos;
      var astral = this.options.ecmaVersion >= 6;
      while (this.pos < this.input.length) {
        var ch = this.fullCharCodeAtPos();
        if (isIdentifierChar2(ch, astral)) {
          this.pos += ch <= 65535 ? 1 : 2;
        } else if (ch === 92) {
          this.containsEsc = true;
          word += this.input.slice(chunkStart, this.pos);
          var escStart = this.pos;
          if (this.input.charCodeAt(++this.pos) !== 117) {
            this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX");
          }
          ++this.pos;
          var esc = this.readCodePoint();
          if (!(first ? isIdentifierStart2 : isIdentifierChar2)(esc, astral)) {
            this.invalidStringToken(escStart, "Invalid Unicode escape");
          }
          word += codePointToString$1(esc);
          chunkStart = this.pos;
        } else {
          break;
        }
        first = false;
      }
      return word + this.input.slice(chunkStart, this.pos);
    };
    pp$92.readWord = function() {
      var word = this.readWord1();
      var type = types2.name;
      if (this.keywords.test(word)) {
        type = keywords$12[word];
      }
      return this.finishToken(type, word);
    };
    version2 = "7.4.1";
    Parser3.acorn = {
      Parser: Parser3,
      version: version2,
      defaultOptions: defaultOptions2,
      Position: Position3,
      SourceLocation: SourceLocation3,
      getLineInfo: getLineInfo2,
      Node: Node3,
      TokenType: TokenType3,
      tokTypes: types2,
      keywordTypes: keywords$12,
      TokContext: TokContext3,
      tokContexts: types$12,
      isIdentifierChar: isIdentifierChar2,
      isIdentifierStart: isIdentifierStart2,
      Token: Token3,
      isNewLine: isNewLine2,
      lineBreak: lineBreak2,
      lineBreakG: lineBreakG2,
      nonASCIIwhitespace: nonASCIIwhitespace2
    };
  }
});

// node_modules/acorn-jsx/index.js
var require_acorn_jsx = __commonJS({
  "node_modules/acorn-jsx/index.js"(exports, module2) {
    "use strict";
    var XHTMLEntities = require_xhtml();
    var hexNumber = /^[\da-fA-F]+$/;
    var decimalNumber = /^\d+$/;
    var acornJsxMap = /* @__PURE__ */ new WeakMap();
    function getJsxTokens(acorn) {
      acorn = acorn.Parser.acorn || acorn;
      let acornJsx2 = acornJsxMap.get(acorn);
      if (!acornJsx2) {
        const tt = acorn.tokTypes;
        const TokContext5 = acorn.TokContext;
        const TokenType5 = acorn.TokenType;
        const tc_oTag = new TokContext5("<tag", false);
        const tc_cTag = new TokContext5("</tag", false);
        const tc_expr = new TokContext5("<tag>...</tag>", true, true);
        const tokContexts = {
          tc_oTag,
          tc_cTag,
          tc_expr
        };
        const tokTypes = {
          jsxName: new TokenType5("jsxName"),
          jsxText: new TokenType5("jsxText", { beforeExpr: true }),
          jsxTagStart: new TokenType5("jsxTagStart", { startsExpr: true }),
          jsxTagEnd: new TokenType5("jsxTagEnd")
        };
        tokTypes.jsxTagStart.updateContext = function() {
          this.context.push(tc_expr);
          this.context.push(tc_oTag);
          this.exprAllowed = false;
        };
        tokTypes.jsxTagEnd.updateContext = function(prevType) {
          let out = this.context.pop();
          if (out === tc_oTag && prevType === tt.slash || out === tc_cTag) {
            this.context.pop();
            this.exprAllowed = this.curContext() === tc_expr;
          } else {
            this.exprAllowed = true;
          }
        };
        acornJsx2 = { tokContexts, tokTypes };
        acornJsxMap.set(acorn, acornJsx2);
      }
      return acornJsx2;
    }
    function getQualifiedJSXName(object) {
      if (!object)
        return object;
      if (object.type === "JSXIdentifier")
        return object.name;
      if (object.type === "JSXNamespacedName")
        return object.namespace.name + ":" + object.name.name;
      if (object.type === "JSXMemberExpression")
        return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
    }
    module2.exports = function(options) {
      options = options || {};
      return function(Parser5) {
        return plugin2({
          allowNamespaces: options.allowNamespaces !== false,
          allowNamespacedObjects: !!options.allowNamespacedObjects
        }, Parser5);
      };
    };
    Object.defineProperty(module2.exports, "tokTypes", {
      get: function get_tokTypes() {
        return getJsxTokens((init_acorn(), __toCommonJS(acorn_exports))).tokTypes;
      },
      configurable: true,
      enumerable: true
    });
    function plugin2(options, Parser5) {
      const acorn = Parser5.acorn || (init_acorn(), __toCommonJS(acorn_exports));
      const acornJsx2 = getJsxTokens(acorn);
      const tt = acorn.tokTypes;
      const tok = acornJsx2.tokTypes;
      const tokContexts = acorn.tokContexts;
      const tc_oTag = acornJsx2.tokContexts.tc_oTag;
      const tc_cTag = acornJsx2.tokContexts.tc_cTag;
      const tc_expr = acornJsx2.tokContexts.tc_expr;
      const isNewLine3 = acorn.isNewLine;
      const isIdentifierStart3 = acorn.isIdentifierStart;
      const isIdentifierChar3 = acorn.isIdentifierChar;
      return class extends Parser5 {
        // Expose actual `tokTypes` and `tokContexts` to other plugins.
        static get acornJsx() {
          return acornJsx2;
        }
        // Reads inline JSX contents token.
        jsx_readToken() {
          let out = "", chunkStart = this.pos;
          for (; ; ) {
            if (this.pos >= this.input.length)
              this.raise(this.start, "Unterminated JSX contents");
            let ch = this.input.charCodeAt(this.pos);
            switch (ch) {
              case 60:
              case 123:
                if (this.pos === this.start) {
                  if (ch === 60 && this.exprAllowed) {
                    ++this.pos;
                    return this.finishToken(tok.jsxTagStart);
                  }
                  return this.getTokenFromCode(ch);
                }
                out += this.input.slice(chunkStart, this.pos);
                return this.finishToken(tok.jsxText, out);
              case 38:
                out += this.input.slice(chunkStart, this.pos);
                out += this.jsx_readEntity();
                chunkStart = this.pos;
                break;
              case 62:
              case 125:
                this.raise(
                  this.pos,
                  "Unexpected token `" + this.input[this.pos] + "`. Did you mean `" + (ch === 62 ? "&gt;" : "&rbrace;") + '` or `{"' + this.input[this.pos] + '"}`?'
                );
              default:
                if (isNewLine3(ch)) {
                  out += this.input.slice(chunkStart, this.pos);
                  out += this.jsx_readNewLine(true);
                  chunkStart = this.pos;
                } else {
                  ++this.pos;
                }
            }
          }
        }
        jsx_readNewLine(normalizeCRLF) {
          let ch = this.input.charCodeAt(this.pos);
          let out;
          ++this.pos;
          if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
            ++this.pos;
            out = normalizeCRLF ? "\n" : "\r\n";
          } else {
            out = String.fromCharCode(ch);
          }
          if (this.options.locations) {
            ++this.curLine;
            this.lineStart = this.pos;
          }
          return out;
        }
        jsx_readString(quote) {
          let out = "", chunkStart = ++this.pos;
          for (; ; ) {
            if (this.pos >= this.input.length)
              this.raise(this.start, "Unterminated string constant");
            let ch = this.input.charCodeAt(this.pos);
            if (ch === quote)
              break;
            if (ch === 38) {
              out += this.input.slice(chunkStart, this.pos);
              out += this.jsx_readEntity();
              chunkStart = this.pos;
            } else if (isNewLine3(ch)) {
              out += this.input.slice(chunkStart, this.pos);
              out += this.jsx_readNewLine(false);
              chunkStart = this.pos;
            } else {
              ++this.pos;
            }
          }
          out += this.input.slice(chunkStart, this.pos++);
          return this.finishToken(tt.string, out);
        }
        jsx_readEntity() {
          let str = "", count = 0, entity;
          let ch = this.input[this.pos];
          if (ch !== "&")
            this.raise(this.pos, "Entity must start with an ampersand");
          let startPos = ++this.pos;
          while (this.pos < this.input.length && count++ < 10) {
            ch = this.input[this.pos++];
            if (ch === ";") {
              if (str[0] === "#") {
                if (str[1] === "x") {
                  str = str.substr(2);
                  if (hexNumber.test(str))
                    entity = String.fromCharCode(parseInt(str, 16));
                } else {
                  str = str.substr(1);
                  if (decimalNumber.test(str))
                    entity = String.fromCharCode(parseInt(str, 10));
                }
              } else {
                entity = XHTMLEntities[str];
              }
              break;
            }
            str += ch;
          }
          if (!entity) {
            this.pos = startPos;
            return "&";
          }
          return entity;
        }
        // Read a JSX identifier (valid tag or attribute name).
        //
        // Optimized version since JSX identifiers can't contain
        // escape characters and so can be read as single slice.
        // Also assumes that first character was already checked
        // by isIdentifierStart in readToken.
        jsx_readWord() {
          let ch, start3 = this.pos;
          do {
            ch = this.input.charCodeAt(++this.pos);
          } while (isIdentifierChar3(ch) || ch === 45);
          return this.finishToken(tok.jsxName, this.input.slice(start3, this.pos));
        }
        // Parse next token as JSX identifier
        jsx_parseIdentifier() {
          let node2 = this.startNode();
          if (this.type === tok.jsxName)
            node2.name = this.value;
          else if (this.type.keyword)
            node2.name = this.type.keyword;
          else
            this.unexpected();
          this.next();
          return this.finishNode(node2, "JSXIdentifier");
        }
        // Parse namespaced identifier.
        jsx_parseNamespacedName() {
          let startPos = this.start, startLoc = this.startLoc;
          let name2 = this.jsx_parseIdentifier();
          if (!options.allowNamespaces || !this.eat(tt.colon))
            return name2;
          var node2 = this.startNodeAt(startPos, startLoc);
          node2.namespace = name2;
          node2.name = this.jsx_parseIdentifier();
          return this.finishNode(node2, "JSXNamespacedName");
        }
        // Parses element name in any form - namespaced, member
        // or single identifier.
        jsx_parseElementName() {
          if (this.type === tok.jsxTagEnd)
            return "";
          let startPos = this.start, startLoc = this.startLoc;
          let node2 = this.jsx_parseNamespacedName();
          if (this.type === tt.dot && node2.type === "JSXNamespacedName" && !options.allowNamespacedObjects) {
            this.unexpected();
          }
          while (this.eat(tt.dot)) {
            let newNode = this.startNodeAt(startPos, startLoc);
            newNode.object = node2;
            newNode.property = this.jsx_parseIdentifier();
            node2 = this.finishNode(newNode, "JSXMemberExpression");
          }
          return node2;
        }
        // Parses any type of JSX attribute value.
        jsx_parseAttributeValue() {
          switch (this.type) {
            case tt.braceL:
              let node2 = this.jsx_parseExpressionContainer();
              if (node2.expression.type === "JSXEmptyExpression")
                this.raise(node2.start, "JSX attributes must only be assigned a non-empty expression");
              return node2;
            case tok.jsxTagStart:
            case tt.string:
              return this.parseExprAtom();
            default:
              this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
          }
        }
        // JSXEmptyExpression is unique type since it doesn't actually parse anything,
        // and so it should start at the end of last read token (left brace) and finish
        // at the beginning of the next one (right brace).
        jsx_parseEmptyExpression() {
          let node2 = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
          return this.finishNodeAt(node2, "JSXEmptyExpression", this.start, this.startLoc);
        }
        // Parses JSX expression enclosed into curly brackets.
        jsx_parseExpressionContainer() {
          let node2 = this.startNode();
          this.next();
          node2.expression = this.type === tt.braceR ? this.jsx_parseEmptyExpression() : this.parseExpression();
          this.expect(tt.braceR);
          return this.finishNode(node2, "JSXExpressionContainer");
        }
        // Parses following JSX attribute name-value pair.
        jsx_parseAttribute() {
          let node2 = this.startNode();
          if (this.eat(tt.braceL)) {
            this.expect(tt.ellipsis);
            node2.argument = this.parseMaybeAssign();
            this.expect(tt.braceR);
            return this.finishNode(node2, "JSXSpreadAttribute");
          }
          node2.name = this.jsx_parseNamespacedName();
          node2.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
          return this.finishNode(node2, "JSXAttribute");
        }
        // Parses JSX opening tag starting after '<'.
        jsx_parseOpeningElementAt(startPos, startLoc) {
          let node2 = this.startNodeAt(startPos, startLoc);
          node2.attributes = [];
          let nodeName = this.jsx_parseElementName();
          if (nodeName)
            node2.name = nodeName;
          while (this.type !== tt.slash && this.type !== tok.jsxTagEnd)
            node2.attributes.push(this.jsx_parseAttribute());
          node2.selfClosing = this.eat(tt.slash);
          this.expect(tok.jsxTagEnd);
          return this.finishNode(node2, nodeName ? "JSXOpeningElement" : "JSXOpeningFragment");
        }
        // Parses JSX closing tag starting after '</'.
        jsx_parseClosingElementAt(startPos, startLoc) {
          let node2 = this.startNodeAt(startPos, startLoc);
          let nodeName = this.jsx_parseElementName();
          if (nodeName)
            node2.name = nodeName;
          this.expect(tok.jsxTagEnd);
          return this.finishNode(node2, nodeName ? "JSXClosingElement" : "JSXClosingFragment");
        }
        // Parses entire JSX element, including it's opening tag
        // (starting after '<'), attributes, contents and closing tag.
        jsx_parseElementAt(startPos, startLoc) {
          let node2 = this.startNodeAt(startPos, startLoc);
          let children = [];
          let openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);
          let closingElement = null;
          if (!openingElement.selfClosing) {
            contents:
              for (; ; ) {
                switch (this.type) {
                  case tok.jsxTagStart:
                    startPos = this.start;
                    startLoc = this.startLoc;
                    this.next();
                    if (this.eat(tt.slash)) {
                      closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);
                      break contents;
                    }
                    children.push(this.jsx_parseElementAt(startPos, startLoc));
                    break;
                  case tok.jsxText:
                    children.push(this.parseExprAtom());
                    break;
                  case tt.braceL:
                    children.push(this.jsx_parseExpressionContainer());
                    break;
                  default:
                    this.unexpected();
                }
              }
            if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
              this.raise(
                closingElement.start,
                "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">"
              );
            }
          }
          let fragmentOrElement = openingElement.name ? "Element" : "Fragment";
          node2["opening" + fragmentOrElement] = openingElement;
          node2["closing" + fragmentOrElement] = closingElement;
          node2.children = children;
          if (this.type === tt.relational && this.value === "<") {
            this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag");
          }
          return this.finishNode(node2, "JSX" + fragmentOrElement);
        }
        // Parse JSX text
        jsx_parseText() {
          let node2 = this.parseLiteral(this.value);
          node2.type = "JSXText";
          return node2;
        }
        // Parses entire JSX element from current position.
        jsx_parseElement() {
          let startPos = this.start, startLoc = this.startLoc;
          this.next();
          return this.jsx_parseElementAt(startPos, startLoc);
        }
        parseExprAtom(refShortHandDefaultPos) {
          if (this.type === tok.jsxText)
            return this.jsx_parseText();
          else if (this.type === tok.jsxTagStart)
            return this.jsx_parseElement();
          else
            return super.parseExprAtom(refShortHandDefaultPos);
        }
        readToken(code2) {
          let context = this.curContext();
          if (context === tc_expr)
            return this.jsx_readToken();
          if (context === tc_oTag || context === tc_cTag) {
            if (isIdentifierStart3(code2))
              return this.jsx_readWord();
            if (code2 == 62) {
              ++this.pos;
              return this.finishToken(tok.jsxTagEnd);
            }
            if ((code2 === 34 || code2 === 39) && context == tc_oTag)
              return this.jsx_readString(code2);
          }
          if (code2 === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {
            ++this.pos;
            return this.finishToken(tok.jsxTagStart);
          }
          return super.readToken(code2);
        }
        updateContext(prevType) {
          if (this.type == tt.braceL) {
            var curContext = this.curContext();
            if (curContext == tc_oTag)
              this.context.push(tokContexts.b_expr);
            else if (curContext == tc_expr)
              this.context.push(tokContexts.b_tmpl);
            else
              super.updateContext(prevType);
            this.exprAllowed = true;
          } else if (this.type === tt.slash && prevType === tok.jsxTagStart) {
            this.context.length -= 2;
            this.context.push(tc_cTag);
            this.exprAllowed = false;
          } else {
            return super.updateContext(prevType);
          }
        }
      };
    }
  }
});

// node_modules/inline-style-parser/index.js
var require_inline_style_parser = __commonJS({
  "node_modules/inline-style-parser/index.js"(exports, module2) {
    var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
    var NEWLINE_REGEX = /\n/g;
    var WHITESPACE_REGEX = /^\s*/;
    var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
    var COLON_REGEX = /^:\s*/;
    var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
    var SEMICOLON_REGEX = /^[;\s]*/;
    var TRIM_REGEX = /^\s+|\s+$/g;
    var NEWLINE = "\n";
    var FORWARD_SLASH = "/";
    var ASTERISK = "*";
    var EMPTY_STRING = "";
    var TYPE_COMMENT = "comment";
    var TYPE_DECLARATION = "declaration";
    module2.exports = function(style, options) {
      if (typeof style !== "string") {
        throw new TypeError("First argument must be a string");
      }
      if (!style)
        return [];
      options = options || {};
      var lineno = 1;
      var column2 = 1;
      function updatePosition(str) {
        var lines = str.match(NEWLINE_REGEX);
        if (lines)
          lineno += lines.length;
        var i = str.lastIndexOf(NEWLINE);
        column2 = ~i ? str.length - i : column2 + str.length;
      }
      function position3() {
        var start3 = { line: lineno, column: column2 };
        return function(node2) {
          node2.position = new Position5(start3);
          whitespace2();
          return node2;
        };
      }
      function Position5(start3) {
        this.start = start3;
        this.end = { line: lineno, column: column2 };
        this.source = options.source;
      }
      Position5.prototype.content = style;
      var errorsList = [];
      function error(msg) {
        var err = new Error(
          options.source + ":" + lineno + ":" + column2 + ": " + msg
        );
        err.reason = msg;
        err.filename = options.source;
        err.line = lineno;
        err.column = column2;
        err.source = style;
        if (options.silent) {
          errorsList.push(err);
        } else {
          throw err;
        }
      }
      function match(re) {
        var m = re.exec(style);
        if (!m)
          return;
        var str = m[0];
        updatePosition(str);
        style = style.slice(str.length);
        return m;
      }
      function whitespace2() {
        match(WHITESPACE_REGEX);
      }
      function comments(rules) {
        var c2;
        rules = rules || [];
        while (c2 = comment2()) {
          if (c2 !== false) {
            rules.push(c2);
          }
        }
        return rules;
      }
      function comment2() {
        var pos2 = position3();
        if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1))
          return;
        var i = 2;
        while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
          ++i;
        }
        i += 2;
        if (EMPTY_STRING === style.charAt(i - 1)) {
          return error("End of comment missing");
        }
        var str = style.slice(2, i - 2);
        column2 += 2;
        updatePosition(str);
        style = style.slice(i);
        column2 += 2;
        return pos2({
          type: TYPE_COMMENT,
          comment: str
        });
      }
      function declaration() {
        var pos2 = position3();
        var prop = match(PROPERTY_REGEX);
        if (!prop)
          return;
        comment2();
        if (!match(COLON_REGEX))
          return error("property missing ':'");
        var val = match(VALUE_REGEX);
        var ret = pos2({
          type: TYPE_DECLARATION,
          property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
          value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
        });
        match(SEMICOLON_REGEX);
        return ret;
      }
      function declarations() {
        var decls = [];
        comments(decls);
        var decl;
        while (decl = declaration()) {
          if (decl !== false) {
            decls.push(decl);
            comments(decls);
          }
        }
        return decls;
      }
      whitespace2();
      return declarations();
    };
    function trim(str) {
      return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
    }
  }
});

// node_modules/style-to-object/index.js
var require_style_to_object = __commonJS({
  "node_modules/style-to-object/index.js"(exports, module2) {
    var parse9 = require_inline_style_parser();
    function StyleToObject2(style, iterator) {
      var output = null;
      if (!style || typeof style !== "string") {
        return output;
      }
      var declaration;
      var declarations = parse9(style);
      var hasIterator = typeof iterator === "function";
      var property;
      var value2;
      for (var i = 0, len = declarations.length; i < len; i++) {
        declaration = declarations[i];
        property = declaration.property;
        value2 = declaration.value;
        if (hasIterator) {
          iterator(property, value2, declaration);
        } else if (value2) {
          output || (output = {});
          output[property] = value2;
        }
      }
      return output;
    }
    module2.exports = StyleToObject2;
    module2.exports.default = StyleToObject2;
  }
});

// node_modules/markdown-extensions/markdown-extensions.json
var require_markdown_extensions = __commonJS({
  "node_modules/markdown-extensions/markdown-extensions.json"(exports, module2) {
    module2.exports = [
      "md",
      "markdown",
      "mdown",
      "mkdn",
      "mkd",
      "mdwn",
      "mkdown",
      "ron"
    ];
  }
});

// node_modules/markdown-extensions/index.js
var require_markdown_extensions2 = __commonJS({
  "node_modules/markdown-extensions/index.js"(exports, module2) {
    "use strict";
    module2.exports = require_markdown_extensions();
  }
});

// node_modules/@jridgewell/set-array/dist/set-array.umd.js
var require_set_array_umd = __commonJS({
  "node_modules/@jridgewell/set-array/dist/set-array.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.setArray = {}));
    })(exports, function(exports2) {
      "use strict";
      exports2.get = void 0;
      exports2.put = void 0;
      exports2.pop = void 0;
      class SetArray {
        constructor() {
          this._indexes = { __proto__: null };
          this.array = [];
        }
      }
      (() => {
        exports2.get = (strarr, key2) => strarr._indexes[key2];
        exports2.put = (strarr, key2) => {
          const index2 = exports2.get(strarr, key2);
          if (index2 !== void 0)
            return index2;
          const { array, _indexes: indexes } = strarr;
          return indexes[key2] = array.push(key2) - 1;
        };
        exports2.pop = (strarr) => {
          const { array, _indexes: indexes } = strarr;
          if (array.length === 0)
            return;
          const last = array.pop();
          indexes[last] = void 0;
        };
      })();
      exports2.SetArray = SetArray;
      Object.defineProperty(exports2, "__esModule", { value: true });
    });
  }
});

// node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
var require_sourcemap_codec_umd = __commonJS({
  "node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.sourcemapCodec = {}));
    })(exports, function(exports2) {
      "use strict";
      const comma = ",".charCodeAt(0);
      const semicolon = ";".charCodeAt(0);
      const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      const intToChar = new Uint8Array(64);
      const charToInt = new Uint8Array(128);
      for (let i = 0; i < chars.length; i++) {
        const c2 = chars.charCodeAt(i);
        intToChar[i] = c2;
        charToInt[c2] = i;
      }
      const td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
        decode(buf) {
          const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
          return out.toString();
        }
      } : {
        decode(buf) {
          let out = "";
          for (let i = 0; i < buf.length; i++) {
            out += String.fromCharCode(buf[i]);
          }
          return out;
        }
      };
      function decode2(mappings) {
        const state = new Int32Array(5);
        const decoded = [];
        let index2 = 0;
        do {
          const semi = indexOf(mappings, index2);
          const line2 = [];
          let sorted = true;
          let lastCol = 0;
          state[0] = 0;
          for (let i = index2; i < semi; i++) {
            let seg;
            i = decodeInteger(mappings, i, state, 0);
            const col = state[0];
            if (col < lastCol)
              sorted = false;
            lastCol = col;
            if (hasMoreVlq(mappings, i, semi)) {
              i = decodeInteger(mappings, i, state, 1);
              i = decodeInteger(mappings, i, state, 2);
              i = decodeInteger(mappings, i, state, 3);
              if (hasMoreVlq(mappings, i, semi)) {
                i = decodeInteger(mappings, i, state, 4);
                seg = [col, state[1], state[2], state[3], state[4]];
              } else {
                seg = [col, state[1], state[2], state[3]];
              }
            } else {
              seg = [col];
            }
            line2.push(seg);
          }
          if (!sorted)
            sort(line2);
          decoded.push(line2);
          index2 = semi + 1;
        } while (index2 <= mappings.length);
        return decoded;
      }
      function indexOf(mappings, index2) {
        const idx = mappings.indexOf(";", index2);
        return idx === -1 ? mappings.length : idx;
      }
      function decodeInteger(mappings, pos2, state, j) {
        let value2 = 0;
        let shift = 0;
        let integer = 0;
        do {
          const c2 = mappings.charCodeAt(pos2++);
          integer = charToInt[c2];
          value2 |= (integer & 31) << shift;
          shift += 5;
        } while (integer & 32);
        const shouldNegate = value2 & 1;
        value2 >>>= 1;
        if (shouldNegate) {
          value2 = -2147483648 | -value2;
        }
        state[j] += value2;
        return pos2;
      }
      function hasMoreVlq(mappings, i, length) {
        if (i >= length)
          return false;
        return mappings.charCodeAt(i) !== comma;
      }
      function sort(line2) {
        line2.sort(sortComparator);
      }
      function sortComparator(a, b) {
        return a[0] - b[0];
      }
      function encode(decoded) {
        const state = new Int32Array(5);
        const bufLength = 1024 * 16;
        const subLength = bufLength - 36;
        const buf = new Uint8Array(bufLength);
        const sub = buf.subarray(0, subLength);
        let pos2 = 0;
        let out = "";
        for (let i = 0; i < decoded.length; i++) {
          const line2 = decoded[i];
          if (i > 0) {
            if (pos2 === bufLength) {
              out += td.decode(buf);
              pos2 = 0;
            }
            buf[pos2++] = semicolon;
          }
          if (line2.length === 0)
            continue;
          state[0] = 0;
          for (let j = 0; j < line2.length; j++) {
            const segment = line2[j];
            if (pos2 > subLength) {
              out += td.decode(sub);
              buf.copyWithin(0, subLength, pos2);
              pos2 -= subLength;
            }
            if (j > 0)
              buf[pos2++] = comma;
            pos2 = encodeInteger(buf, pos2, state, segment, 0);
            if (segment.length === 1)
              continue;
            pos2 = encodeInteger(buf, pos2, state, segment, 1);
            pos2 = encodeInteger(buf, pos2, state, segment, 2);
            pos2 = encodeInteger(buf, pos2, state, segment, 3);
            if (segment.length === 4)
              continue;
            pos2 = encodeInteger(buf, pos2, state, segment, 4);
          }
        }
        return out + td.decode(buf.subarray(0, pos2));
      }
      function encodeInteger(buf, pos2, state, segment, j) {
        const next = segment[j];
        let num = next - state[j];
        state[j] = next;
        num = num < 0 ? -num << 1 | 1 : num << 1;
        do {
          let clamped = num & 31;
          num >>>= 5;
          if (num > 0)
            clamped |= 32;
          buf[pos2++] = intToChar[clamped];
        } while (num > 0);
        return pos2;
      }
      exports2.decode = decode2;
      exports2.encode = encode;
      Object.defineProperty(exports2, "__esModule", { value: true });
    });
  }
});

// node_modules/@jridgewell/trace-mapping/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
var require_sourcemap_codec_umd2 = __commonJS({
  "node_modules/@jridgewell/trace-mapping/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.sourcemapCodec = {}));
    })(exports, function(exports2) {
      "use strict";
      const comma = ",".charCodeAt(0);
      const semicolon = ";".charCodeAt(0);
      const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      const intToChar = new Uint8Array(64);
      const charToInt = new Uint8Array(128);
      for (let i = 0; i < chars.length; i++) {
        const c2 = chars.charCodeAt(i);
        intToChar[i] = c2;
        charToInt[c2] = i;
      }
      const td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
        decode(buf) {
          const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
          return out.toString();
        }
      } : {
        decode(buf) {
          let out = "";
          for (let i = 0; i < buf.length; i++) {
            out += String.fromCharCode(buf[i]);
          }
          return out;
        }
      };
      function decode2(mappings) {
        const state = new Int32Array(5);
        const decoded = [];
        let index2 = 0;
        do {
          const semi = indexOf(mappings, index2);
          const line2 = [];
          let sorted = true;
          let lastCol = 0;
          state[0] = 0;
          for (let i = index2; i < semi; i++) {
            let seg;
            i = decodeInteger(mappings, i, state, 0);
            const col = state[0];
            if (col < lastCol)
              sorted = false;
            lastCol = col;
            if (hasMoreVlq(mappings, i, semi)) {
              i = decodeInteger(mappings, i, state, 1);
              i = decodeInteger(mappings, i, state, 2);
              i = decodeInteger(mappings, i, state, 3);
              if (hasMoreVlq(mappings, i, semi)) {
                i = decodeInteger(mappings, i, state, 4);
                seg = [col, state[1], state[2], state[3], state[4]];
              } else {
                seg = [col, state[1], state[2], state[3]];
              }
            } else {
              seg = [col];
            }
            line2.push(seg);
          }
          if (!sorted)
            sort(line2);
          decoded.push(line2);
          index2 = semi + 1;
        } while (index2 <= mappings.length);
        return decoded;
      }
      function indexOf(mappings, index2) {
        const idx = mappings.indexOf(";", index2);
        return idx === -1 ? mappings.length : idx;
      }
      function decodeInteger(mappings, pos2, state, j) {
        let value2 = 0;
        let shift = 0;
        let integer = 0;
        do {
          const c2 = mappings.charCodeAt(pos2++);
          integer = charToInt[c2];
          value2 |= (integer & 31) << shift;
          shift += 5;
        } while (integer & 32);
        const shouldNegate = value2 & 1;
        value2 >>>= 1;
        if (shouldNegate) {
          value2 = -2147483648 | -value2;
        }
        state[j] += value2;
        return pos2;
      }
      function hasMoreVlq(mappings, i, length) {
        if (i >= length)
          return false;
        return mappings.charCodeAt(i) !== comma;
      }
      function sort(line2) {
        line2.sort(sortComparator);
      }
      function sortComparator(a, b) {
        return a[0] - b[0];
      }
      function encode(decoded) {
        const state = new Int32Array(5);
        const bufLength = 1024 * 16;
        const subLength = bufLength - 36;
        const buf = new Uint8Array(bufLength);
        const sub = buf.subarray(0, subLength);
        let pos2 = 0;
        let out = "";
        for (let i = 0; i < decoded.length; i++) {
          const line2 = decoded[i];
          if (i > 0) {
            if (pos2 === bufLength) {
              out += td.decode(buf);
              pos2 = 0;
            }
            buf[pos2++] = semicolon;
          }
          if (line2.length === 0)
            continue;
          state[0] = 0;
          for (let j = 0; j < line2.length; j++) {
            const segment = line2[j];
            if (pos2 > subLength) {
              out += td.decode(sub);
              buf.copyWithin(0, subLength, pos2);
              pos2 -= subLength;
            }
            if (j > 0)
              buf[pos2++] = comma;
            pos2 = encodeInteger(buf, pos2, state, segment, 0);
            if (segment.length === 1)
              continue;
            pos2 = encodeInteger(buf, pos2, state, segment, 1);
            pos2 = encodeInteger(buf, pos2, state, segment, 2);
            pos2 = encodeInteger(buf, pos2, state, segment, 3);
            if (segment.length === 4)
              continue;
            pos2 = encodeInteger(buf, pos2, state, segment, 4);
          }
        }
        return out + td.decode(buf.subarray(0, pos2));
      }
      function encodeInteger(buf, pos2, state, segment, j) {
        const next = segment[j];
        let num = next - state[j];
        state[j] = next;
        num = num < 0 ? -num << 1 | 1 : num << 1;
        do {
          let clamped = num & 31;
          num >>>= 5;
          if (num > 0)
            clamped |= 32;
          buf[pos2++] = intToChar[clamped];
        } while (num > 0);
        return pos2;
      }
      exports2.decode = decode2;
      exports2.encode = encode;
      Object.defineProperty(exports2, "__esModule", { value: true });
    });
  }
});

// node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
var require_resolve_uri_umd = __commonJS({
  "node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.resolveURI = factory());
    })(exports, function() {
      "use strict";
      const schemeRegex = /^[\w+.-]+:\/\//;
      const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
      const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
      var UrlType;
      (function(UrlType2) {
        UrlType2[UrlType2["Empty"] = 1] = "Empty";
        UrlType2[UrlType2["Hash"] = 2] = "Hash";
        UrlType2[UrlType2["Query"] = 3] = "Query";
        UrlType2[UrlType2["RelativePath"] = 4] = "RelativePath";
        UrlType2[UrlType2["AbsolutePath"] = 5] = "AbsolutePath";
        UrlType2[UrlType2["SchemeRelative"] = 6] = "SchemeRelative";
        UrlType2[UrlType2["Absolute"] = 7] = "Absolute";
      })(UrlType || (UrlType = {}));
      function isAbsoluteUrl(input) {
        return schemeRegex.test(input);
      }
      function isSchemeRelativeUrl(input) {
        return input.startsWith("//");
      }
      function isAbsolutePath(input) {
        return input.startsWith("/");
      }
      function isFileUrl(input) {
        return input.startsWith("file:");
      }
      function isRelative(input) {
        return /^[.?#]/.test(input);
      }
      function parseAbsoluteUrl(input) {
        const match = urlRegex.exec(input);
        return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
      }
      function parseFileUrl(input) {
        const match = fileRegex.exec(input);
        const path = match[2];
        return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
      }
      function makeUrl(scheme, user, host, port, path, query, hash) {
        return {
          scheme,
          user,
          host,
          port,
          path,
          query,
          hash,
          type: UrlType.Absolute
        };
      }
      function parseUrl(input) {
        if (isSchemeRelativeUrl(input)) {
          const url2 = parseAbsoluteUrl("http:" + input);
          url2.scheme = "";
          url2.type = UrlType.SchemeRelative;
          return url2;
        }
        if (isAbsolutePath(input)) {
          const url2 = parseAbsoluteUrl("http://foo.com" + input);
          url2.scheme = "";
          url2.host = "";
          url2.type = UrlType.AbsolutePath;
          return url2;
        }
        if (isFileUrl(input))
          return parseFileUrl(input);
        if (isAbsoluteUrl(input))
          return parseAbsoluteUrl(input);
        const url = parseAbsoluteUrl("http://foo.com/" + input);
        url.scheme = "";
        url.host = "";
        url.type = input ? input.startsWith("?") ? UrlType.Query : input.startsWith("#") ? UrlType.Hash : UrlType.RelativePath : UrlType.Empty;
        return url;
      }
      function stripPathFilename(path) {
        if (path.endsWith("/.."))
          return path;
        const index2 = path.lastIndexOf("/");
        return path.slice(0, index2 + 1);
      }
      function mergePaths(url, base2) {
        normalizePath(base2, base2.type);
        if (url.path === "/") {
          url.path = base2.path;
        } else {
          url.path = stripPathFilename(base2.path) + url.path;
        }
      }
      function normalizePath(url, type) {
        const rel = type <= UrlType.RelativePath;
        const pieces = url.path.split("/");
        let pointer = 1;
        let positive = 0;
        let addTrailingSlash = false;
        for (let i = 1; i < pieces.length; i++) {
          const piece = pieces[i];
          if (!piece) {
            addTrailingSlash = true;
            continue;
          }
          addTrailingSlash = false;
          if (piece === ".")
            continue;
          if (piece === "..") {
            if (positive) {
              addTrailingSlash = true;
              positive--;
              pointer--;
            } else if (rel) {
              pieces[pointer++] = piece;
            }
            continue;
          }
          pieces[pointer++] = piece;
          positive++;
        }
        let path = "";
        for (let i = 1; i < pointer; i++) {
          path += "/" + pieces[i];
        }
        if (!path || addTrailingSlash && !path.endsWith("/..")) {
          path += "/";
        }
        url.path = path;
      }
      function resolve(input, base2) {
        if (!input && !base2)
          return "";
        const url = parseUrl(input);
        let inputType = url.type;
        if (base2 && inputType !== UrlType.Absolute) {
          const baseUrl = parseUrl(base2);
          const baseType = baseUrl.type;
          switch (inputType) {
            case UrlType.Empty:
              url.hash = baseUrl.hash;
            case UrlType.Hash:
              url.query = baseUrl.query;
            case UrlType.Query:
            case UrlType.RelativePath:
              mergePaths(url, baseUrl);
            case UrlType.AbsolutePath:
              url.user = baseUrl.user;
              url.host = baseUrl.host;
              url.port = baseUrl.port;
            case UrlType.SchemeRelative:
              url.scheme = baseUrl.scheme;
          }
          if (baseType > inputType)
            inputType = baseType;
        }
        normalizePath(url, inputType);
        const queryHash = url.query + url.hash;
        switch (inputType) {
          case UrlType.Hash:
          case UrlType.Query:
            return queryHash;
          case UrlType.RelativePath: {
            const path = url.path.slice(1);
            if (!path)
              return queryHash || ".";
            if (isRelative(base2 || input) && !isRelative(path)) {
              return "./" + path + queryHash;
            }
            return path + queryHash;
          }
          case UrlType.AbsolutePath:
            return url.path + queryHash;
          default:
            return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
        }
      }
      return resolve;
    });
  }
});

// node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
var require_trace_mapping_umd = __commonJS({
  "node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports, require_sourcemap_codec_umd2(), require_resolve_uri_umd()) : typeof define === "function" && define.amd ? define(["exports", "@jridgewell/sourcemap-codec", "@jridgewell/resolve-uri"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.traceMapping = {}, global2.sourcemapCodec, global2.resolveURI));
    })(exports, function(exports2, sourcemapCodec, resolveUri) {
      "use strict";
      function _interopDefaultLegacy(e) {
        return e && typeof e === "object" && "default" in e ? e : { "default": e };
      }
      var resolveUri__default = /* @__PURE__ */ _interopDefaultLegacy(resolveUri);
      function resolve(input, base2) {
        if (base2 && !base2.endsWith("/"))
          base2 += "/";
        return resolveUri__default["default"](input, base2);
      }
      function stripFilename(path) {
        if (!path)
          return "";
        const index2 = path.lastIndexOf("/");
        return path.slice(0, index2 + 1);
      }
      const COLUMN = 0;
      const SOURCES_INDEX = 1;
      const SOURCE_LINE = 2;
      const SOURCE_COLUMN = 3;
      const NAMES_INDEX = 4;
      const REV_GENERATED_LINE = 1;
      const REV_GENERATED_COLUMN = 2;
      function maybeSort(mappings, owned) {
        const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
        if (unsortedIndex === mappings.length)
          return mappings;
        if (!owned)
          mappings = mappings.slice();
        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
          mappings[i] = sortSegments(mappings[i], owned);
        }
        return mappings;
      }
      function nextUnsortedSegmentLine(mappings, start3) {
        for (let i = start3; i < mappings.length; i++) {
          if (!isSorted(mappings[i]))
            return i;
        }
        return mappings.length;
      }
      function isSorted(line2) {
        for (let j = 1; j < line2.length; j++) {
          if (line2[j][COLUMN] < line2[j - 1][COLUMN]) {
            return false;
          }
        }
        return true;
      }
      function sortSegments(line2, owned) {
        if (!owned)
          line2 = line2.slice();
        return line2.sort(sortComparator);
      }
      function sortComparator(a, b) {
        return a[COLUMN] - b[COLUMN];
      }
      let found = false;
      function binarySearch(haystack, needle, low, high) {
        while (low <= high) {
          const mid = low + (high - low >> 1);
          const cmp = haystack[mid][COLUMN] - needle;
          if (cmp === 0) {
            found = true;
            return mid;
          }
          if (cmp < 0) {
            low = mid + 1;
          } else {
            high = mid - 1;
          }
        }
        found = false;
        return low - 1;
      }
      function upperBound(haystack, needle, index2) {
        for (let i = index2 + 1; i < haystack.length; index2 = i++) {
          if (haystack[i][COLUMN] !== needle)
            break;
        }
        return index2;
      }
      function lowerBound(haystack, needle, index2) {
        for (let i = index2 - 1; i >= 0; index2 = i--) {
          if (haystack[i][COLUMN] !== needle)
            break;
        }
        return index2;
      }
      function memoizedState() {
        return {
          lastKey: -1,
          lastNeedle: -1,
          lastIndex: -1
        };
      }
      function memoizedBinarySearch(haystack, needle, state, key2) {
        const { lastKey, lastNeedle, lastIndex } = state;
        let low = 0;
        let high = haystack.length - 1;
        if (key2 === lastKey) {
          if (needle === lastNeedle) {
            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
            return lastIndex;
          }
          if (needle >= lastNeedle) {
            low = lastIndex === -1 ? 0 : lastIndex;
          } else {
            high = lastIndex;
          }
        }
        state.lastKey = key2;
        state.lastNeedle = needle;
        return state.lastIndex = binarySearch(haystack, needle, low, high);
      }
      function buildBySources(decoded, memos) {
        const sources = memos.map(buildNullArray);
        for (let i = 0; i < decoded.length; i++) {
          const line2 = decoded[i];
          for (let j = 0; j < line2.length; j++) {
            const seg = line2[j];
            if (seg.length === 1)
              continue;
            const sourceIndex = seg[SOURCES_INDEX];
            const sourceLine = seg[SOURCE_LINE];
            const sourceColumn = seg[SOURCE_COLUMN];
            const originalSource = sources[sourceIndex];
            const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
            const memo = memos[sourceIndex];
            const index2 = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
            insert(originalLine, memo.lastIndex = index2 + 1, [sourceColumn, i, seg[COLUMN]]);
          }
        }
        return sources;
      }
      function insert(array, index2, value2) {
        for (let i = array.length; i > index2; i--) {
          array[i] = array[i - 1];
        }
        array[index2] = value2;
      }
      function buildNullArray() {
        return { __proto__: null };
      }
      const AnyMap = function(map, mapUrl) {
        const parsed = typeof map === "string" ? JSON.parse(map) : map;
        if (!("sections" in parsed))
          return new TraceMap(parsed, mapUrl);
        const mappings = [];
        const sources = [];
        const sourcesContent = [];
        const names = [];
        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
        const joined = {
          version: 3,
          file: parsed.file,
          names,
          sources,
          sourcesContent,
          mappings
        };
        return exports2.presortedDecodedMap(joined);
      };
      function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
        const { sections } = input;
        for (let i = 0; i < sections.length; i++) {
          const { map, offset: offset3 } = sections[i];
          let sl = stopLine;
          let sc = stopColumn;
          if (i + 1 < sections.length) {
            const nextOffset = sections[i + 1].offset;
            sl = Math.min(stopLine, lineOffset + nextOffset.line);
            if (sl === stopLine) {
              sc = Math.min(stopColumn, columnOffset + nextOffset.column);
            } else if (sl < stopLine) {
              sc = columnOffset + nextOffset.column;
            }
          }
          addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset3.line, columnOffset + offset3.column, sl, sc);
        }
      }
      function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
        if ("sections" in input)
          return recurse(...arguments);
        const map = new TraceMap(input, mapUrl);
        const sourcesOffset = sources.length;
        const namesOffset = names.length;
        const decoded = exports2.decodedMappings(map);
        const { resolvedSources, sourcesContent: contents } = map;
        append(sources, resolvedSources);
        append(names, map.names);
        if (contents)
          append(sourcesContent, contents);
        else
          for (let i = 0; i < resolvedSources.length; i++)
            sourcesContent.push(null);
        for (let i = 0; i < decoded.length; i++) {
          const lineI = lineOffset + i;
          if (lineI > stopLine)
            return;
          const out = getLine(mappings, lineI);
          const cOffset = i === 0 ? columnOffset : 0;
          const line2 = decoded[i];
          for (let j = 0; j < line2.length; j++) {
            const seg = line2[j];
            const column2 = cOffset + seg[COLUMN];
            if (lineI === stopLine && column2 >= stopColumn)
              return;
            if (seg.length === 1) {
              out.push([column2]);
              continue;
            }
            const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
            const sourceLine = seg[SOURCE_LINE];
            const sourceColumn = seg[SOURCE_COLUMN];
            out.push(seg.length === 4 ? [column2, sourcesIndex, sourceLine, sourceColumn] : [column2, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
          }
        }
      }
      function append(arr, other) {
        for (let i = 0; i < other.length; i++)
          arr.push(other[i]);
      }
      function getLine(arr, index2) {
        for (let i = arr.length; i <= index2; i++)
          arr[i] = [];
        return arr[index2];
      }
      const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
      const COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
      const LEAST_UPPER_BOUND = -1;
      const GREATEST_LOWER_BOUND = 1;
      exports2.encodedMappings = void 0;
      exports2.decodedMappings = void 0;
      exports2.traceSegment = void 0;
      exports2.originalPositionFor = void 0;
      exports2.generatedPositionFor = void 0;
      exports2.allGeneratedPositionsFor = void 0;
      exports2.eachMapping = void 0;
      exports2.sourceContentFor = void 0;
      exports2.presortedDecodedMap = void 0;
      exports2.decodedMap = void 0;
      exports2.encodedMap = void 0;
      class TraceMap {
        constructor(map, mapUrl) {
          const isString = typeof map === "string";
          if (!isString && map._decodedMemo)
            return map;
          const parsed = isString ? JSON.parse(map) : map;
          const { version: version3, file, names, sourceRoot, sources, sourcesContent } = parsed;
          this.version = version3;
          this.file = file;
          this.names = names;
          this.sourceRoot = sourceRoot;
          this.sources = sources;
          this.sourcesContent = sourcesContent;
          const from = resolve(sourceRoot || "", stripFilename(mapUrl));
          this.resolvedSources = sources.map((s) => resolve(s || "", from));
          const { mappings } = parsed;
          if (typeof mappings === "string") {
            this._encoded = mappings;
            this._decoded = void 0;
          } else {
            this._encoded = void 0;
            this._decoded = maybeSort(mappings, isString);
          }
          this._decodedMemo = memoizedState();
          this._bySources = void 0;
          this._bySourceMemos = void 0;
        }
      }
      (() => {
        exports2.encodedMappings = (map) => {
          var _a;
          return (_a = map._encoded) !== null && _a !== void 0 ? _a : map._encoded = sourcemapCodec.encode(map._decoded);
        };
        exports2.decodedMappings = (map) => {
          return map._decoded || (map._decoded = sourcemapCodec.decode(map._encoded));
        };
        exports2.traceSegment = (map, line2, column2) => {
          const decoded = exports2.decodedMappings(map);
          if (line2 >= decoded.length)
            return null;
          const segments = decoded[line2];
          const index2 = traceSegmentInternal(segments, map._decodedMemo, line2, column2, GREATEST_LOWER_BOUND);
          return index2 === -1 ? null : segments[index2];
        };
        exports2.originalPositionFor = (map, { line: line2, column: column2, bias }) => {
          line2--;
          if (line2 < 0)
            throw new Error(LINE_GTR_ZERO);
          if (column2 < 0)
            throw new Error(COL_GTR_EQ_ZERO);
          const decoded = exports2.decodedMappings(map);
          if (line2 >= decoded.length)
            return OMapping(null, null, null, null);
          const segments = decoded[line2];
          const index2 = traceSegmentInternal(segments, map._decodedMemo, line2, column2, bias || GREATEST_LOWER_BOUND);
          if (index2 === -1)
            return OMapping(null, null, null, null);
          const segment = segments[index2];
          if (segment.length === 1)
            return OMapping(null, null, null, null);
          const { names, resolvedSources } = map;
          return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
        };
        exports2.allGeneratedPositionsFor = (map, { source: source2, line: line2, column: column2, bias }) => {
          return generatedPosition(map, source2, line2, column2, bias || LEAST_UPPER_BOUND, true);
        };
        exports2.generatedPositionFor = (map, { source: source2, line: line2, column: column2, bias }) => {
          return generatedPosition(map, source2, line2, column2, bias || GREATEST_LOWER_BOUND, false);
        };
        exports2.eachMapping = (map, cb) => {
          const decoded = exports2.decodedMappings(map);
          const { names, resolvedSources } = map;
          for (let i = 0; i < decoded.length; i++) {
            const line2 = decoded[i];
            for (let j = 0; j < line2.length; j++) {
              const seg = line2[j];
              const generatedLine = i + 1;
              const generatedColumn = seg[0];
              let source2 = null;
              let originalLine = null;
              let originalColumn = null;
              let name2 = null;
              if (seg.length !== 1) {
                source2 = resolvedSources[seg[1]];
                originalLine = seg[2] + 1;
                originalColumn = seg[3];
              }
              if (seg.length === 5)
                name2 = names[seg[4]];
              cb({
                generatedLine,
                generatedColumn,
                source: source2,
                originalLine,
                originalColumn,
                name: name2
              });
            }
          }
        };
        exports2.sourceContentFor = (map, source2) => {
          const { sources, resolvedSources, sourcesContent } = map;
          if (sourcesContent == null)
            return null;
          let index2 = sources.indexOf(source2);
          if (index2 === -1)
            index2 = resolvedSources.indexOf(source2);
          return index2 === -1 ? null : sourcesContent[index2];
        };
        exports2.presortedDecodedMap = (map, mapUrl) => {
          const tracer = new TraceMap(clone(map, []), mapUrl);
          tracer._decoded = map.mappings;
          return tracer;
        };
        exports2.decodedMap = (map) => {
          return clone(map, exports2.decodedMappings(map));
        };
        exports2.encodedMap = (map) => {
          return clone(map, exports2.encodedMappings(map));
        };
        function generatedPosition(map, source2, line2, column2, bias, all4) {
          line2--;
          if (line2 < 0)
            throw new Error(LINE_GTR_ZERO);
          if (column2 < 0)
            throw new Error(COL_GTR_EQ_ZERO);
          const { sources, resolvedSources } = map;
          let sourceIndex = sources.indexOf(source2);
          if (sourceIndex === -1)
            sourceIndex = resolvedSources.indexOf(source2);
          if (sourceIndex === -1)
            return all4 ? [] : GMapping(null, null);
          const generated2 = map._bySources || (map._bySources = buildBySources(exports2.decodedMappings(map), map._bySourceMemos = sources.map(memoizedState)));
          const segments = generated2[sourceIndex][line2];
          if (segments == null)
            return all4 ? [] : GMapping(null, null);
          const memo = map._bySourceMemos[sourceIndex];
          if (all4)
            return sliceGeneratedPositions(segments, memo, line2, column2, bias);
          const index2 = traceSegmentInternal(segments, memo, line2, column2, bias);
          if (index2 === -1)
            return GMapping(null, null);
          const segment = segments[index2];
          return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
        }
      })();
      function clone(map, mappings) {
        return {
          version: map.version,
          file: map.file,
          names: map.names,
          sourceRoot: map.sourceRoot,
          sources: map.sources,
          sourcesContent: map.sourcesContent,
          mappings
        };
      }
      function OMapping(source2, line2, column2, name2) {
        return { source: source2, line: line2, column: column2, name: name2 };
      }
      function GMapping(line2, column2) {
        return { line: line2, column: column2 };
      }
      function traceSegmentInternal(segments, memo, line2, column2, bias) {
        let index2 = memoizedBinarySearch(segments, column2, memo, line2);
        if (found) {
          index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column2, index2);
        } else if (bias === LEAST_UPPER_BOUND)
          index2++;
        if (index2 === -1 || index2 === segments.length)
          return -1;
        return index2;
      }
      function sliceGeneratedPositions(segments, memo, line2, column2, bias) {
        let min = traceSegmentInternal(segments, memo, line2, column2, GREATEST_LOWER_BOUND);
        if (!found && bias === LEAST_UPPER_BOUND)
          min++;
        if (min === -1 || min === segments.length)
          return [];
        const matchedColumn = found ? column2 : segments[min][COLUMN];
        if (!found)
          min = lowerBound(segments, matchedColumn, min);
        const max = upperBound(segments, matchedColumn, min);
        const result = [];
        for (; min <= max; min++) {
          const segment = segments[min];
          result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
        }
        return result;
      }
      exports2.AnyMap = AnyMap;
      exports2.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND;
      exports2.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND;
      exports2.TraceMap = TraceMap;
      Object.defineProperty(exports2, "__esModule", { value: true });
    });
  }
});

// node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
var require_gen_mapping_umd = __commonJS({
  "node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports, require_set_array_umd(), require_sourcemap_codec_umd(), require_trace_mapping_umd()) : typeof define === "function" && define.amd ? define(["exports", "@jridgewell/set-array", "@jridgewell/sourcemap-codec", "@jridgewell/trace-mapping"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.genMapping = {}, global2.setArray, global2.sourcemapCodec, global2.traceMapping));
    })(exports, function(exports2, setArray, sourcemapCodec, traceMapping) {
      "use strict";
      const COLUMN = 0;
      const SOURCES_INDEX = 1;
      const SOURCE_LINE = 2;
      const SOURCE_COLUMN = 3;
      const NAMES_INDEX = 4;
      const NO_NAME = -1;
      exports2.addSegment = void 0;
      exports2.addMapping = void 0;
      exports2.maybeAddSegment = void 0;
      exports2.maybeAddMapping = void 0;
      exports2.setSourceContent = void 0;
      exports2.toDecodedMap = void 0;
      exports2.toEncodedMap = void 0;
      exports2.fromMap = void 0;
      exports2.allMappings = void 0;
      let addSegmentInternal;
      class GenMapping {
        constructor({ file, sourceRoot } = {}) {
          this._names = new setArray.SetArray();
          this._sources = new setArray.SetArray();
          this._sourcesContent = [];
          this._mappings = [];
          this.file = file;
          this.sourceRoot = sourceRoot;
        }
      }
      (() => {
        exports2.addSegment = (map, genLine, genColumn, source2, sourceLine, sourceColumn, name2, content3) => {
          return addSegmentInternal(false, map, genLine, genColumn, source2, sourceLine, sourceColumn, name2, content3);
        };
        exports2.maybeAddSegment = (map, genLine, genColumn, source2, sourceLine, sourceColumn, name2, content3) => {
          return addSegmentInternal(true, map, genLine, genColumn, source2, sourceLine, sourceColumn, name2, content3);
        };
        exports2.addMapping = (map, mapping) => {
          return addMappingInternal(false, map, mapping);
        };
        exports2.maybeAddMapping = (map, mapping) => {
          return addMappingInternal(true, map, mapping);
        };
        exports2.setSourceContent = (map, source2, content3) => {
          const { _sources: sources, _sourcesContent: sourcesContent } = map;
          sourcesContent[setArray.put(sources, source2)] = content3;
        };
        exports2.toDecodedMap = (map) => {
          const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = map;
          removeEmptyFinalLines(mappings);
          return {
            version: 3,
            file: file || void 0,
            names: names.array,
            sourceRoot: sourceRoot || void 0,
            sources: sources.array,
            sourcesContent,
            mappings
          };
        };
        exports2.toEncodedMap = (map) => {
          const decoded = exports2.toDecodedMap(map);
          return Object.assign(Object.assign({}, decoded), { mappings: sourcemapCodec.encode(decoded.mappings) });
        };
        exports2.allMappings = (map) => {
          const out = [];
          const { _mappings: mappings, _sources: sources, _names: names } = map;
          for (let i = 0; i < mappings.length; i++) {
            const line2 = mappings[i];
            for (let j = 0; j < line2.length; j++) {
              const seg = line2[j];
              const generated2 = { line: i + 1, column: seg[COLUMN] };
              let source2 = void 0;
              let original = void 0;
              let name2 = void 0;
              if (seg.length !== 1) {
                source2 = sources.array[seg[SOURCES_INDEX]];
                original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
                if (seg.length === 5)
                  name2 = names.array[seg[NAMES_INDEX]];
              }
              out.push({ generated: generated2, source: source2, original, name: name2 });
            }
          }
          return out;
        };
        exports2.fromMap = (input) => {
          const map = new traceMapping.TraceMap(input);
          const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
          putAll(gen._names, map.names);
          putAll(gen._sources, map.sources);
          gen._sourcesContent = map.sourcesContent || map.sources.map(() => null);
          gen._mappings = traceMapping.decodedMappings(map);
          return gen;
        };
        addSegmentInternal = (skipable, map, genLine, genColumn, source2, sourceLine, sourceColumn, name2, content3) => {
          const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = map;
          const line2 = getLine(mappings, genLine);
          const index2 = getColumnIndex(line2, genColumn);
          if (!source2) {
            if (skipable && skipSourceless(line2, index2))
              return;
            return insert(line2, index2, [genColumn]);
          }
          const sourcesIndex = setArray.put(sources, source2);
          const namesIndex = name2 ? setArray.put(names, name2) : NO_NAME;
          if (sourcesIndex === sourcesContent.length)
            sourcesContent[sourcesIndex] = content3 !== null && content3 !== void 0 ? content3 : null;
          if (skipable && skipSource(line2, index2, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
            return;
          }
          return insert(line2, index2, name2 ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
        };
      })();
      function getLine(mappings, index2) {
        for (let i = mappings.length; i <= index2; i++) {
          mappings[i] = [];
        }
        return mappings[index2];
      }
      function getColumnIndex(line2, genColumn) {
        let index2 = line2.length;
        for (let i = index2 - 1; i >= 0; index2 = i--) {
          const current3 = line2[i];
          if (genColumn >= current3[COLUMN])
            break;
        }
        return index2;
      }
      function insert(array, index2, value2) {
        for (let i = array.length; i > index2; i--) {
          array[i] = array[i - 1];
        }
        array[index2] = value2;
      }
      function removeEmptyFinalLines(mappings) {
        const { length } = mappings;
        let len = length;
        for (let i = len - 1; i >= 0; len = i, i--) {
          if (mappings[i].length > 0)
            break;
        }
        if (len < length)
          mappings.length = len;
      }
      function putAll(strarr, array) {
        for (let i = 0; i < array.length; i++)
          setArray.put(strarr, array[i]);
      }
      function skipSourceless(line2, index2) {
        if (index2 === 0)
          return true;
        const prev = line2[index2 - 1];
        return prev.length === 1;
      }
      function skipSource(line2, index2, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
        if (index2 === 0)
          return false;
        const prev = line2[index2 - 1];
        if (prev.length === 1)
          return false;
        return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
      }
      function addMappingInternal(skipable, map, mapping) {
        const { generated: generated2, source: source2, original, name: name2, content: content3 } = mapping;
        if (!source2) {
          return addSegmentInternal(skipable, map, generated2.line - 1, generated2.column, null, null, null, null, null);
        }
        const s = source2;
        return addSegmentInternal(skipable, map, generated2.line - 1, generated2.column, s, original.line - 1, original.column, name2, content3);
      }
      exports2.GenMapping = GenMapping;
      Object.defineProperty(exports2, "__esModule", { value: true });
    });
  }
});

// node_modules/@babel/generator/lib/source-map.js
var require_source_map = __commonJS({
  "node_modules/@babel/generator/lib/source-map.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _genMapping = require_gen_mapping_umd();
    var _traceMapping = require_trace_mapping_umd();
    var SourceMap = class {
      constructor(opts, code2) {
        var _opts$sourceFileName;
        this._map = void 0;
        this._rawMappings = void 0;
        this._sourceFileName = void 0;
        this._lastGenLine = 0;
        this._lastSourceLine = 0;
        this._lastSourceColumn = 0;
        this._inputMap = void 0;
        const map = this._map = new _genMapping.GenMapping({
          sourceRoot: opts.sourceRoot
        });
        this._sourceFileName = (_opts$sourceFileName = opts.sourceFileName) == null ? void 0 : _opts$sourceFileName.replace(/\\/g, "/");
        this._rawMappings = void 0;
        if (opts.inputSourceMap) {
          this._inputMap = new _traceMapping.TraceMap(opts.inputSourceMap);
          const resolvedSources = this._inputMap.resolvedSources;
          if (resolvedSources.length) {
            for (let i = 0; i < resolvedSources.length; i++) {
              var _this$_inputMap$sourc;
              (0, _genMapping.setSourceContent)(map, resolvedSources[i], (_this$_inputMap$sourc = this._inputMap.sourcesContent) == null ? void 0 : _this$_inputMap$sourc[i]);
            }
          }
        }
        if (typeof code2 === "string" && !opts.inputSourceMap) {
          (0, _genMapping.setSourceContent)(map, this._sourceFileName, code2);
        } else if (typeof code2 === "object") {
          for (const sourceFileName of Object.keys(code2)) {
            (0, _genMapping.setSourceContent)(map, sourceFileName.replace(/\\/g, "/"), code2[sourceFileName]);
          }
        }
      }
      get() {
        return (0, _genMapping.toEncodedMap)(this._map);
      }
      getDecoded() {
        return (0, _genMapping.toDecodedMap)(this._map);
      }
      getRawMappings() {
        return this._rawMappings || (this._rawMappings = (0, _genMapping.allMappings)(this._map));
      }
      mark(generated2, line2, column2, identifierName, identifierNamePos, filename) {
        var _originalMapping;
        this._rawMappings = void 0;
        let originalMapping;
        if (line2 != null) {
          if (this._inputMap) {
            originalMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, {
              line: line2,
              column: column2
            });
            if (!originalMapping.name && identifierNamePos) {
              const originalIdentifierMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, identifierNamePos);
              if (originalIdentifierMapping.name) {
                identifierName = originalIdentifierMapping.name;
              }
            }
          } else {
            originalMapping = {
              source: (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
              line: line2,
              column: column2
            };
          }
        }
        (0, _genMapping.maybeAddMapping)(this._map, {
          name: identifierName,
          generated: generated2,
          source: (_originalMapping = originalMapping) == null ? void 0 : _originalMapping.source,
          original: originalMapping
        });
      }
    };
    exports.default = SourceMap;
  }
});

// node_modules/@babel/generator/lib/buffer.js
var require_buffer = __commonJS({
  "node_modules/@babel/generator/lib/buffer.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var Buffer2 = class {
      constructor(map) {
        this._map = null;
        this._buf = "";
        this._str = "";
        this._appendCount = 0;
        this._last = 0;
        this._queue = [];
        this._queueCursor = 0;
        this._canMarkIdName = true;
        this._position = {
          line: 1,
          column: 0
        };
        this._sourcePosition = {
          identifierName: void 0,
          identifierNamePos: void 0,
          line: void 0,
          column: void 0,
          filename: void 0
        };
        this._map = map;
        this._allocQueue();
      }
      _allocQueue() {
        const queue = this._queue;
        for (let i = 0; i < 16; i++) {
          queue.push({
            char: 0,
            repeat: 1,
            line: void 0,
            column: void 0,
            identifierName: void 0,
            identifierNamePos: void 0,
            filename: ""
          });
        }
      }
      _pushQueue(char, repeat, line2, column2, filename) {
        const cursor = this._queueCursor;
        if (cursor === this._queue.length) {
          this._allocQueue();
        }
        const item = this._queue[cursor];
        item.char = char;
        item.repeat = repeat;
        item.line = line2;
        item.column = column2;
        item.filename = filename;
        this._queueCursor++;
      }
      _popQueue() {
        if (this._queueCursor === 0) {
          throw new Error("Cannot pop from empty queue");
        }
        return this._queue[--this._queueCursor];
      }
      get() {
        this._flush();
        const map = this._map;
        const result = {
          code: (this._buf + this._str).trimRight(),
          decodedMap: map == null ? void 0 : map.getDecoded(),
          get __mergedMap() {
            return this.map;
          },
          get map() {
            const resultMap = map ? map.get() : null;
            result.map = resultMap;
            return resultMap;
          },
          set map(value2) {
            Object.defineProperty(result, "map", {
              value: value2,
              writable: true
            });
          },
          get rawMappings() {
            const mappings = map == null ? void 0 : map.getRawMappings();
            result.rawMappings = mappings;
            return mappings;
          },
          set rawMappings(value2) {
            Object.defineProperty(result, "rawMappings", {
              value: value2,
              writable: true
            });
          }
        };
        return result;
      }
      append(str, maybeNewline) {
        this._flush();
        this._append(str, this._sourcePosition, maybeNewline);
      }
      appendChar(char) {
        this._flush();
        this._appendChar(char, 1, this._sourcePosition);
      }
      queue(char) {
        if (char === 10) {
          while (this._queueCursor !== 0) {
            const char2 = this._queue[this._queueCursor - 1].char;
            if (char2 !== 32 && char2 !== 9) {
              break;
            }
            this._queueCursor--;
          }
        }
        const sourcePosition = this._sourcePosition;
        this._pushQueue(char, 1, sourcePosition.line, sourcePosition.column, sourcePosition.filename);
      }
      queueIndentation(char, repeat) {
        this._pushQueue(char, repeat, void 0, void 0, void 0);
      }
      _flush() {
        const queueCursor = this._queueCursor;
        const queue = this._queue;
        for (let i = 0; i < queueCursor; i++) {
          const item = queue[i];
          this._appendChar(item.char, item.repeat, item);
        }
        this._queueCursor = 0;
      }
      _appendChar(char, repeat, sourcePos) {
        this._last = char;
        this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
        if (char !== 10) {
          this._mark(sourcePos.line, sourcePos.column, sourcePos.identifierName, sourcePos.identifierNamePos, sourcePos.filename);
          this._position.column += repeat;
        } else {
          this._position.line++;
          this._position.column = 0;
        }
        if (this._canMarkIdName) {
          sourcePos.identifierName = void 0;
          sourcePos.identifierNamePos = void 0;
        }
      }
      _append(str, sourcePos, maybeNewline) {
        const len = str.length;
        const position3 = this._position;
        this._last = str.charCodeAt(len - 1);
        if (++this._appendCount > 4096) {
          +this._str;
          this._buf += this._str;
          this._str = str;
          this._appendCount = 0;
        } else {
          this._str += str;
        }
        if (!maybeNewline && !this._map) {
          position3.column += len;
          return;
        }
        const {
          column: column2,
          identifierName,
          identifierNamePos,
          filename
        } = sourcePos;
        let line2 = sourcePos.line;
        if ((identifierName != null || identifierNamePos != null) && this._canMarkIdName) {
          sourcePos.identifierName = void 0;
          sourcePos.identifierNamePos = void 0;
        }
        let i = str.indexOf("\n");
        let last = 0;
        if (i !== 0) {
          this._mark(line2, column2, identifierName, identifierNamePos, filename);
        }
        while (i !== -1) {
          position3.line++;
          position3.column = 0;
          last = i + 1;
          if (last < len && line2 !== void 0) {
            this._mark(++line2, 0, null, null, filename);
          }
          i = str.indexOf("\n", last);
        }
        position3.column += len - last;
      }
      _mark(line2, column2, identifierName, identifierNamePos, filename) {
        var _this$_map;
        (_this$_map = this._map) == null ? void 0 : _this$_map.mark(this._position, line2, column2, identifierName, identifierNamePos, filename);
      }
      removeTrailingNewline() {
        const queueCursor = this._queueCursor;
        if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 10) {
          this._queueCursor--;
        }
      }
      removeLastSemicolon() {
        const queueCursor = this._queueCursor;
        if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 59) {
          this._queueCursor--;
        }
      }
      getLastChar() {
        const queueCursor = this._queueCursor;
        return queueCursor !== 0 ? this._queue[queueCursor - 1].char : this._last;
      }
      getNewlineCount() {
        const queueCursor = this._queueCursor;
        let count = 0;
        if (queueCursor === 0)
          return this._last === 10 ? 1 : 0;
        for (let i = queueCursor - 1; i >= 0; i--) {
          if (this._queue[i].char !== 10) {
            break;
          }
          count++;
        }
        return count === queueCursor && this._last === 10 ? count + 1 : count;
      }
      endsWithCharAndNewline() {
        const queue = this._queue;
        const queueCursor = this._queueCursor;
        if (queueCursor !== 0) {
          const lastCp = queue[queueCursor - 1].char;
          if (lastCp !== 10)
            return;
          if (queueCursor > 1) {
            return queue[queueCursor - 2].char;
          } else {
            return this._last;
          }
        }
      }
      hasContent() {
        return this._queueCursor !== 0 || !!this._last;
      }
      exactSource(loc, cb) {
        if (!this._map) {
          cb();
          return;
        }
        this.source("start", loc);
        const identifierName = loc.identifierName;
        const sourcePos = this._sourcePosition;
        if (identifierName) {
          this._canMarkIdName = false;
          sourcePos.identifierName = identifierName;
        }
        cb();
        if (identifierName) {
          this._canMarkIdName = true;
          sourcePos.identifierName = void 0;
          sourcePos.identifierNamePos = void 0;
        }
        this.source("end", loc);
      }
      source(prop, loc) {
        if (!this._map)
          return;
        this._normalizePosition(prop, loc, 0, 0);
      }
      sourceWithOffset(prop, loc, lineOffset, columnOffset) {
        if (!this._map)
          return;
        this._normalizePosition(prop, loc, lineOffset, columnOffset);
      }
      withSource(prop, loc, cb) {
        if (this._map) {
          this.source(prop, loc);
        }
        cb();
      }
      _normalizePosition(prop, loc, lineOffset, columnOffset) {
        const pos2 = loc[prop];
        const target = this._sourcePosition;
        if (pos2) {
          target.line = pos2.line + lineOffset;
          target.column = pos2.column + columnOffset;
          target.filename = loc.filename;
        }
      }
      getCurrentColumn() {
        const queue = this._queue;
        const queueCursor = this._queueCursor;
        let lastIndex = -1;
        let len = 0;
        for (let i = 0; i < queueCursor; i++) {
          const item = queue[i];
          if (item.char === 10) {
            lastIndex = len;
          }
          len += item.repeat;
        }
        return lastIndex === -1 ? this._position.column + len : len - 1 - lastIndex;
      }
      getCurrentLine() {
        let count = 0;
        const queue = this._queue;
        for (let i = 0; i < this._queueCursor; i++) {
          if (queue[i].char === 10) {
            count++;
          }
        }
        return this._position.line + count;
      }
    };
    exports.default = Buffer2;
  }
});

// node_modules/@babel/types/lib/utils/shallowEqual.js
var require_shallowEqual = __commonJS({
  "node_modules/@babel/types/lib/utils/shallowEqual.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = shallowEqual;
    function shallowEqual(actual, expected) {
      const keys2 = Object.keys(expected);
      for (const key2 of keys2) {
        if (actual[key2] !== expected[key2]) {
          return false;
        }
      }
      return true;
    }
  }
});

// node_modules/@babel/types/lib/utils/deprecationWarning.js
var require_deprecationWarning = __commonJS({
  "node_modules/@babel/types/lib/utils/deprecationWarning.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = deprecationWarning;
    var warnings = /* @__PURE__ */ new Set();
    function deprecationWarning(oldName, newName, prefix = "") {
      if (warnings.has(oldName))
        return;
      warnings.add(oldName);
      const {
        internal,
        trace
      } = captureShortStackTrace(1, 2);
      if (internal) {
        return;
      }
      console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`
${trace}`);
    }
    function captureShortStackTrace(skip, length) {
      const {
        stackTraceLimit,
        prepareStackTrace
      } = Error;
      let stackTrace;
      Error.stackTraceLimit = 1 + skip + length;
      Error.prepareStackTrace = function(err, stack2) {
        stackTrace = stack2;
      };
      new Error().stack;
      Error.stackTraceLimit = stackTraceLimit;
      Error.prepareStackTrace = prepareStackTrace;
      if (!stackTrace)
        return {
          internal: false,
          trace: ""
        };
      const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);
      return {
        internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()),
        trace: shortStackTrace.map((frame) => `    at ${frame}`).join("\n")
      };
    }
  }
});

// node_modules/@babel/types/lib/validators/generated/index.js
var require_generated = __commonJS({
  "node_modules/@babel/types/lib/validators/generated/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isAccessor = isAccessor;
    exports.isAnyTypeAnnotation = isAnyTypeAnnotation;
    exports.isArgumentPlaceholder = isArgumentPlaceholder;
    exports.isArrayExpression = isArrayExpression;
    exports.isArrayPattern = isArrayPattern;
    exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
    exports.isArrowFunctionExpression = isArrowFunctionExpression2;
    exports.isAssignmentExpression = isAssignmentExpression;
    exports.isAssignmentPattern = isAssignmentPattern;
    exports.isAwaitExpression = isAwaitExpression;
    exports.isBigIntLiteral = isBigIntLiteral;
    exports.isBinary = isBinary;
    exports.isBinaryExpression = isBinaryExpression;
    exports.isBindExpression = isBindExpression;
    exports.isBlock = isBlock;
    exports.isBlockParent = isBlockParent;
    exports.isBlockStatement = isBlockStatement;
    exports.isBooleanLiteral = isBooleanLiteral;
    exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
    exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
    exports.isBreakStatement = isBreakStatement;
    exports.isCallExpression = isCallExpression2;
    exports.isCatchClause = isCatchClause;
    exports.isClass = isClass;
    exports.isClassAccessorProperty = isClassAccessorProperty;
    exports.isClassBody = isClassBody;
    exports.isClassDeclaration = isClassDeclaration;
    exports.isClassExpression = isClassExpression;
    exports.isClassImplements = isClassImplements;
    exports.isClassMethod = isClassMethod;
    exports.isClassPrivateMethod = isClassPrivateMethod;
    exports.isClassPrivateProperty = isClassPrivateProperty;
    exports.isClassProperty = isClassProperty;
    exports.isCompletionStatement = isCompletionStatement;
    exports.isConditional = isConditional;
    exports.isConditionalExpression = isConditionalExpression;
    exports.isContinueStatement = isContinueStatement;
    exports.isDebuggerStatement = isDebuggerStatement;
    exports.isDecimalLiteral = isDecimalLiteral;
    exports.isDeclaration = isDeclaration2;
    exports.isDeclareClass = isDeclareClass;
    exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
    exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
    exports.isDeclareFunction = isDeclareFunction;
    exports.isDeclareInterface = isDeclareInterface;
    exports.isDeclareModule = isDeclareModule;
    exports.isDeclareModuleExports = isDeclareModuleExports;
    exports.isDeclareOpaqueType = isDeclareOpaqueType;
    exports.isDeclareTypeAlias = isDeclareTypeAlias;
    exports.isDeclareVariable = isDeclareVariable;
    exports.isDeclaredPredicate = isDeclaredPredicate;
    exports.isDecorator = isDecorator;
    exports.isDirective = isDirective;
    exports.isDirectiveLiteral = isDirectiveLiteral;
    exports.isDoExpression = isDoExpression;
    exports.isDoWhileStatement = isDoWhileStatement;
    exports.isEmptyStatement = isEmptyStatement;
    exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
    exports.isEnumBody = isEnumBody;
    exports.isEnumBooleanBody = isEnumBooleanBody;
    exports.isEnumBooleanMember = isEnumBooleanMember;
    exports.isEnumDeclaration = isEnumDeclaration;
    exports.isEnumDefaultedMember = isEnumDefaultedMember;
    exports.isEnumMember = isEnumMember;
    exports.isEnumNumberBody = isEnumNumberBody;
    exports.isEnumNumberMember = isEnumNumberMember;
    exports.isEnumStringBody = isEnumStringBody;
    exports.isEnumStringMember = isEnumStringMember;
    exports.isEnumSymbolBody = isEnumSymbolBody;
    exports.isExistsTypeAnnotation = isExistsTypeAnnotation;
    exports.isExportAllDeclaration = isExportAllDeclaration;
    exports.isExportDeclaration = isExportDeclaration;
    exports.isExportDefaultDeclaration = isExportDefaultDeclaration;
    exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
    exports.isExportNamedDeclaration = isExportNamedDeclaration2;
    exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
    exports.isExportSpecifier = isExportSpecifier;
    exports.isExpression = isExpression;
    exports.isExpressionStatement = isExpressionStatement2;
    exports.isExpressionWrapper = isExpressionWrapper;
    exports.isFile = isFile;
    exports.isFlow = isFlow;
    exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
    exports.isFlowDeclaration = isFlowDeclaration;
    exports.isFlowPredicate = isFlowPredicate;
    exports.isFlowType = isFlowType;
    exports.isFor = isFor;
    exports.isForInStatement = isForInStatement;
    exports.isForOfStatement = isForOfStatement;
    exports.isForStatement = isForStatement;
    exports.isForXStatement = isForXStatement;
    exports.isFunction = isFunction;
    exports.isFunctionDeclaration = isFunctionDeclaration;
    exports.isFunctionExpression = isFunctionExpression;
    exports.isFunctionParent = isFunctionParent;
    exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
    exports.isFunctionTypeParam = isFunctionTypeParam;
    exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
    exports.isIdentifier = isIdentifier3;
    exports.isIfStatement = isIfStatement;
    exports.isImmutable = isImmutable;
    exports.isImport = isImport;
    exports.isImportAttribute = isImportAttribute;
    exports.isImportDeclaration = isImportDeclaration;
    exports.isImportDefaultSpecifier = isImportDefaultSpecifier;
    exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
    exports.isImportOrExportDeclaration = isImportOrExportDeclaration;
    exports.isImportSpecifier = isImportSpecifier;
    exports.isIndexedAccessType = isIndexedAccessType;
    exports.isInferredPredicate = isInferredPredicate;
    exports.isInterfaceDeclaration = isInterfaceDeclaration;
    exports.isInterfaceExtends = isInterfaceExtends;
    exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
    exports.isInterpreterDirective = isInterpreterDirective;
    exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
    exports.isJSX = isJSX;
    exports.isJSXAttribute = isJSXAttribute;
    exports.isJSXClosingElement = isJSXClosingElement;
    exports.isJSXClosingFragment = isJSXClosingFragment;
    exports.isJSXElement = isJSXElement3;
    exports.isJSXEmptyExpression = isJSXEmptyExpression;
    exports.isJSXExpressionContainer = isJSXExpressionContainer3;
    exports.isJSXFragment = isJSXFragment2;
    exports.isJSXIdentifier = isJSXIdentifier3;
    exports.isJSXMemberExpression = isJSXMemberExpression;
    exports.isJSXNamespacedName = isJSXNamespacedName;
    exports.isJSXOpeningElement = isJSXOpeningElement;
    exports.isJSXOpeningFragment = isJSXOpeningFragment;
    exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
    exports.isJSXSpreadChild = isJSXSpreadChild;
    exports.isJSXText = isJSXText2;
    exports.isLVal = isLVal;
    exports.isLabeledStatement = isLabeledStatement;
    exports.isLiteral = isLiteral;
    exports.isLogicalExpression = isLogicalExpression;
    exports.isLoop = isLoop;
    exports.isMemberExpression = isMemberExpression2;
    exports.isMetaProperty = isMetaProperty;
    exports.isMethod = isMethod;
    exports.isMiscellaneous = isMiscellaneous;
    exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
    exports.isModuleDeclaration = isModuleDeclaration;
    exports.isModuleExpression = isModuleExpression;
    exports.isModuleSpecifier = isModuleSpecifier;
    exports.isNewExpression = isNewExpression;
    exports.isNoop = isNoop;
    exports.isNullLiteral = isNullLiteral;
    exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
    exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
    exports.isNumberLiteral = isNumberLiteral;
    exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
    exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
    exports.isNumericLiteral = isNumericLiteral;
    exports.isObjectExpression = isObjectExpression2;
    exports.isObjectMember = isObjectMember;
    exports.isObjectMethod = isObjectMethod;
    exports.isObjectPattern = isObjectPattern;
    exports.isObjectProperty = isObjectProperty;
    exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
    exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
    exports.isObjectTypeIndexer = isObjectTypeIndexer;
    exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
    exports.isObjectTypeProperty = isObjectTypeProperty;
    exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
    exports.isOpaqueType = isOpaqueType;
    exports.isOptionalCallExpression = isOptionalCallExpression;
    exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType;
    exports.isOptionalMemberExpression = isOptionalMemberExpression;
    exports.isParenthesizedExpression = isParenthesizedExpression;
    exports.isPattern = isPattern;
    exports.isPatternLike = isPatternLike;
    exports.isPipelineBareFunction = isPipelineBareFunction;
    exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
    exports.isPipelineTopicExpression = isPipelineTopicExpression;
    exports.isPlaceholder = isPlaceholder;
    exports.isPrivate = isPrivate;
    exports.isPrivateName = isPrivateName;
    exports.isProgram = isProgram;
    exports.isProperty = isProperty;
    exports.isPureish = isPureish;
    exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
    exports.isRecordExpression = isRecordExpression;
    exports.isRegExpLiteral = isRegExpLiteral;
    exports.isRegexLiteral = isRegexLiteral;
    exports.isRestElement = isRestElement;
    exports.isRestProperty = isRestProperty;
    exports.isReturnStatement = isReturnStatement;
    exports.isScopable = isScopable;
    exports.isSequenceExpression = isSequenceExpression;
    exports.isSpreadElement = isSpreadElement;
    exports.isSpreadProperty = isSpreadProperty;
    exports.isStandardized = isStandardized;
    exports.isStatement = isStatement;
    exports.isStaticBlock = isStaticBlock;
    exports.isStringLiteral = isStringLiteral2;
    exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
    exports.isStringTypeAnnotation = isStringTypeAnnotation;
    exports.isSuper = isSuper;
    exports.isSwitchCase = isSwitchCase;
    exports.isSwitchStatement = isSwitchStatement;
    exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation;
    exports.isTSAnyKeyword = isTSAnyKeyword;
    exports.isTSArrayType = isTSArrayType;
    exports.isTSAsExpression = isTSAsExpression;
    exports.isTSBaseType = isTSBaseType;
    exports.isTSBigIntKeyword = isTSBigIntKeyword;
    exports.isTSBooleanKeyword = isTSBooleanKeyword;
    exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
    exports.isTSConditionalType = isTSConditionalType;
    exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
    exports.isTSConstructorType = isTSConstructorType;
    exports.isTSDeclareFunction = isTSDeclareFunction;
    exports.isTSDeclareMethod = isTSDeclareMethod;
    exports.isTSEntityName = isTSEntityName;
    exports.isTSEnumDeclaration = isTSEnumDeclaration;
    exports.isTSEnumMember = isTSEnumMember;
    exports.isTSExportAssignment = isTSExportAssignment;
    exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
    exports.isTSExternalModuleReference = isTSExternalModuleReference;
    exports.isTSFunctionType = isTSFunctionType;
    exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
    exports.isTSImportType = isTSImportType;
    exports.isTSIndexSignature = isTSIndexSignature;
    exports.isTSIndexedAccessType = isTSIndexedAccessType;
    exports.isTSInferType = isTSInferType;
    exports.isTSInstantiationExpression = isTSInstantiationExpression;
    exports.isTSInterfaceBody = isTSInterfaceBody;
    exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
    exports.isTSIntersectionType = isTSIntersectionType;
    exports.isTSIntrinsicKeyword = isTSIntrinsicKeyword;
    exports.isTSLiteralType = isTSLiteralType;
    exports.isTSMappedType = isTSMappedType;
    exports.isTSMethodSignature = isTSMethodSignature;
    exports.isTSModuleBlock = isTSModuleBlock;
    exports.isTSModuleDeclaration = isTSModuleDeclaration;
    exports.isTSNamedTupleMember = isTSNamedTupleMember;
    exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
    exports.isTSNeverKeyword = isTSNeverKeyword;
    exports.isTSNonNullExpression = isTSNonNullExpression;
    exports.isTSNullKeyword = isTSNullKeyword;
    exports.isTSNumberKeyword = isTSNumberKeyword;
    exports.isTSObjectKeyword = isTSObjectKeyword;
    exports.isTSOptionalType = isTSOptionalType;
    exports.isTSParameterProperty = isTSParameterProperty;
    exports.isTSParenthesizedType = isTSParenthesizedType;
    exports.isTSPropertySignature = isTSPropertySignature;
    exports.isTSQualifiedName = isTSQualifiedName;
    exports.isTSRestType = isTSRestType;
    exports.isTSSatisfiesExpression = isTSSatisfiesExpression;
    exports.isTSStringKeyword = isTSStringKeyword;
    exports.isTSSymbolKeyword = isTSSymbolKeyword;
    exports.isTSThisType = isTSThisType;
    exports.isTSTupleType = isTSTupleType;
    exports.isTSType = isTSType;
    exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
    exports.isTSTypeAnnotation = isTSTypeAnnotation;
    exports.isTSTypeAssertion = isTSTypeAssertion;
    exports.isTSTypeElement = isTSTypeElement;
    exports.isTSTypeLiteral = isTSTypeLiteral;
    exports.isTSTypeOperator = isTSTypeOperator;
    exports.isTSTypeParameter = isTSTypeParameter;
    exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
    exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
    exports.isTSTypePredicate = isTSTypePredicate;
    exports.isTSTypeQuery = isTSTypeQuery;
    exports.isTSTypeReference = isTSTypeReference;
    exports.isTSUndefinedKeyword = isTSUndefinedKeyword;
    exports.isTSUnionType = isTSUnionType;
    exports.isTSUnknownKeyword = isTSUnknownKeyword;
    exports.isTSVoidKeyword = isTSVoidKeyword;
    exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
    exports.isTemplateElement = isTemplateElement;
    exports.isTemplateLiteral = isTemplateLiteral;
    exports.isTerminatorless = isTerminatorless;
    exports.isThisExpression = isThisExpression;
    exports.isThisTypeAnnotation = isThisTypeAnnotation;
    exports.isThrowStatement = isThrowStatement;
    exports.isTopicReference = isTopicReference;
    exports.isTryStatement = isTryStatement;
    exports.isTupleExpression = isTupleExpression;
    exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
    exports.isTypeAlias = isTypeAlias;
    exports.isTypeAnnotation = isTypeAnnotation;
    exports.isTypeCastExpression = isTypeCastExpression;
    exports.isTypeParameter = isTypeParameter;
    exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
    exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
    exports.isTypeScript = isTypeScript;
    exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
    exports.isUnaryExpression = isUnaryExpression;
    exports.isUnaryLike = isUnaryLike;
    exports.isUnionTypeAnnotation = isUnionTypeAnnotation;
    exports.isUpdateExpression = isUpdateExpression;
    exports.isUserWhitespacable = isUserWhitespacable;
    exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;
    exports.isVariableDeclaration = isVariableDeclaration2;
    exports.isVariableDeclarator = isVariableDeclarator2;
    exports.isVariance = isVariance;
    exports.isVoidTypeAnnotation = isVoidTypeAnnotation;
    exports.isWhile = isWhile;
    exports.isWhileStatement = isWhileStatement;
    exports.isWithStatement = isWithStatement;
    exports.isYieldExpression = isYieldExpression;
    var _shallowEqual = require_shallowEqual();
    var _deprecationWarning = require_deprecationWarning();
    function isArrayExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ArrayExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isAssignmentExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "AssignmentExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBinaryExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BinaryExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isInterpreterDirective(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "InterpreterDirective") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDirective(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Directive") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDirectiveLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DirectiveLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBlockStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BlockStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBreakStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BreakStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isCallExpression2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "CallExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isCatchClause(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "CatchClause") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isConditionalExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ConditionalExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isContinueStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ContinueStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDebuggerStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DebuggerStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDoWhileStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DoWhileStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEmptyStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EmptyStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExpressionStatement2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExpressionStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFile(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "File") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isForInStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ForInStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isForStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ForStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFunctionDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "FunctionDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFunctionExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "FunctionExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isIdentifier3(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Identifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isIfStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "IfStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isLabeledStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "LabeledStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isStringLiteral2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "StringLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNumericLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NumericLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNullLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NullLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBooleanLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BooleanLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isRegExpLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "RegExpLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isLogicalExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "LogicalExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isMemberExpression2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "MemberExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNewExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NewExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isProgram(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Program") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectExpression2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectMethod(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectMethod") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isRestElement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "RestElement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isReturnStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ReturnStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSequenceExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "SequenceExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isParenthesizedExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ParenthesizedExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSwitchCase(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "SwitchCase") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSwitchStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "SwitchStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isThisExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ThisExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isThrowStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ThrowStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTryStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TryStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isUnaryExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "UnaryExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isUpdateExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "UpdateExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isVariableDeclaration2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "VariableDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isVariableDeclarator2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "VariableDeclarator") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isWhileStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "WhileStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isWithStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "WithStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isAssignmentPattern(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "AssignmentPattern") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isArrayPattern(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ArrayPattern") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isArrowFunctionExpression2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ArrowFunctionExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassBody") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportAllDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExportAllDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportDefaultDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExportDefaultDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportNamedDeclaration2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExportNamedDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExportSpecifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isForOfStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ForOfStatement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImportDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ImportDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImportDefaultSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ImportDefaultSpecifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImportNamespaceSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ImportNamespaceSpecifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImportSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ImportSpecifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isMetaProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "MetaProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassMethod(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassMethod") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectPattern(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectPattern") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSpreadElement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "SpreadElement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSuper(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Super") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTaggedTemplateExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TaggedTemplateExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTemplateElement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TemplateElement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTemplateLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TemplateLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isYieldExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "YieldExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isAwaitExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "AwaitExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImport(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Import") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBigIntLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BigIntLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportNamespaceSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExportNamespaceSpecifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isOptionalMemberExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "OptionalMemberExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isOptionalCallExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "OptionalCallExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassAccessorProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassAccessorProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassPrivateProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassPrivateProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassPrivateMethod(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassPrivateMethod") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPrivateName(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "PrivateName") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isStaticBlock(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "StaticBlock") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isAnyTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "AnyTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isArrayTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ArrayTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBooleanTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BooleanTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBooleanLiteralTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BooleanLiteralTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNullLiteralTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NullLiteralTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClassImplements(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ClassImplements") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareClass(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareClass") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareFunction(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareFunction") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareInterface(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareInterface") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareModule(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareModule") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareModuleExports(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareModuleExports") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareTypeAlias(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareTypeAlias") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareOpaqueType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareOpaqueType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareVariable(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareVariable") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareExportDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareExportDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclareExportAllDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclareExportAllDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclaredPredicate(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DeclaredPredicate") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExistsTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExistsTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFunctionTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "FunctionTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFunctionTypeParam(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "FunctionTypeParam") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isGenericTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "GenericTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isInferredPredicate(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "InferredPredicate") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isInterfaceExtends(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "InterfaceExtends") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isInterfaceDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "InterfaceDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isInterfaceTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "InterfaceTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isIntersectionTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "IntersectionTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isMixedTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "MixedTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEmptyTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EmptyTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNullableTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NullableTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNumberLiteralTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NumberLiteralTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNumberTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NumberTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectTypeInternalSlot(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectTypeInternalSlot") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectTypeCallProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectTypeCallProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectTypeIndexer(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectTypeIndexer") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectTypeProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectTypeProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectTypeSpreadProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ObjectTypeSpreadProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isOpaqueType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "OpaqueType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isQualifiedTypeIdentifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "QualifiedTypeIdentifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isStringLiteralTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "StringLiteralTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isStringTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "StringTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSymbolTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "SymbolTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isThisTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ThisTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTupleTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TupleTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeofTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeofTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeAlias(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeAlias") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeCastExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeCastExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeParameter(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeParameter") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeParameterDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeParameterDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeParameterInstantiation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TypeParameterInstantiation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isUnionTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "UnionTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isVariance(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Variance") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isVoidTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "VoidTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumBooleanBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumBooleanBody") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumNumberBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumNumberBody") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumStringBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumStringBody") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumSymbolBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumSymbolBody") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumBooleanMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumBooleanMember") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumNumberMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumNumberMember") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumStringMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumStringMember") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumDefaultedMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "EnumDefaultedMember") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isIndexedAccessType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "IndexedAccessType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isOptionalIndexedAccessType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "OptionalIndexedAccessType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXAttribute(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXAttribute") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXClosingElement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXClosingElement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXElement3(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXElement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXEmptyExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXEmptyExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXExpressionContainer3(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXExpressionContainer") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXSpreadChild(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXSpreadChild") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXIdentifier3(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXIdentifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXMemberExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXMemberExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXNamespacedName(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXNamespacedName") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXOpeningElement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXOpeningElement") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXSpreadAttribute(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXSpreadAttribute") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXText2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXText") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXFragment2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXFragment") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXOpeningFragment(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXOpeningFragment") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSXClosingFragment(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "JSXClosingFragment") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNoop(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Noop") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPlaceholder(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Placeholder") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isV8IntrinsicIdentifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "V8IntrinsicIdentifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isArgumentPlaceholder(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ArgumentPlaceholder") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBindExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "BindExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImportAttribute(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ImportAttribute") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDecorator(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "Decorator") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDoExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DoExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportDefaultSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ExportDefaultSpecifier") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isRecordExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "RecordExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTupleExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TupleExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDecimalLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "DecimalLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isModuleExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "ModuleExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTopicReference(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TopicReference") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPipelineTopicExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "PipelineTopicExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPipelineBareFunction(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "PipelineBareFunction") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPipelinePrimaryTopicReference(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "PipelinePrimaryTopicReference") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSParameterProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSParameterProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSDeclareFunction(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSDeclareFunction") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSDeclareMethod(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSDeclareMethod") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSQualifiedName(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSQualifiedName") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSCallSignatureDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSCallSignatureDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSConstructSignatureDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSConstructSignatureDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSPropertySignature(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSPropertySignature") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSMethodSignature(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSMethodSignature") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSIndexSignature(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSIndexSignature") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSAnyKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSAnyKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSBooleanKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSBooleanKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSBigIntKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSBigIntKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSIntrinsicKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSIntrinsicKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSNeverKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSNeverKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSNullKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSNullKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSNumberKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSNumberKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSObjectKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSObjectKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSStringKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSStringKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSSymbolKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSSymbolKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSUndefinedKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSUndefinedKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSUnknownKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSUnknownKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSVoidKeyword(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSVoidKeyword") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSThisType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSThisType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSFunctionType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSFunctionType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSConstructorType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSConstructorType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeReference(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeReference") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypePredicate(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypePredicate") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeQuery(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeQuery") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSArrayType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSArrayType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTupleType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTupleType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSOptionalType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSOptionalType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSRestType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSRestType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSNamedTupleMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSNamedTupleMember") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSUnionType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSUnionType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSIntersectionType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSIntersectionType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSConditionalType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSConditionalType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSInferType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSInferType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSParenthesizedType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSParenthesizedType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeOperator(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeOperator") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSIndexedAccessType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSIndexedAccessType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSMappedType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSMappedType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSLiteralType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSLiteralType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSExpressionWithTypeArguments(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSExpressionWithTypeArguments") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSInterfaceDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSInterfaceDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSInterfaceBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSInterfaceBody") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeAliasDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeAliasDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSInstantiationExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSInstantiationExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSAsExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSAsExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSSatisfiesExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSSatisfiesExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeAssertion(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeAssertion") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSEnumDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSEnumDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSEnumMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSEnumMember") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSModuleDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSModuleDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSModuleBlock(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSModuleBlock") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSImportType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSImportType") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSImportEqualsDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSImportEqualsDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSExternalModuleReference(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSExternalModuleReference") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSNonNullExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSNonNullExpression") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSExportAssignment(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSExportAssignment") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSNamespaceExportDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSNamespaceExportDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeAnnotation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeParameterInstantiation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeParameterInstantiation") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeParameterDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeParameterDeclaration") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeParameter(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "TSTypeParameter") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isStandardized(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "InterpreterDirective" === nodeType || "Directive" === nodeType || "DirectiveLiteral" === nodeType || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "CallExpression" === nodeType || "CatchClause" === nodeType || "ConditionalExpression" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "File" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "Program" === nodeType || "ObjectExpression" === nodeType || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "RestElement" === nodeType || "ReturnStatement" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "SwitchCase" === nodeType || "SwitchStatement" === nodeType || "ThisExpression" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "VariableDeclaration" === nodeType || "VariableDeclarator" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassBody" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ExportSpecifier" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "MetaProperty" === nodeType || "ClassMethod" === nodeType || "ObjectPattern" === nodeType || "SpreadElement" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateElement" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "ExportNamespaceSpecifier" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "ClassProperty" === nodeType || "ClassAccessorProperty" === nodeType || "ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType || "StaticBlock" === nodeType || nodeType === "Placeholder" && ("Identifier" === node2.expectedNode || "StringLiteral" === node2.expectedNode || "BlockStatement" === node2.expectedNode || "ClassBody" === node2.expectedNode)) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExpression(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "BindExpression" === nodeType || "DoExpression" === nodeType || "RecordExpression" === nodeType || "TupleExpression" === nodeType || "DecimalLiteral" === nodeType || "ModuleExpression" === nodeType || "TopicReference" === nodeType || "PipelineTopicExpression" === nodeType || "PipelineBareFunction" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSSatisfiesExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node2.expectedNode || "Identifier" === node2.expectedNode || "StringLiteral" === node2.expectedNode)) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBinary(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BinaryExpression" === nodeType || "LogicalExpression" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isScopable(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBlockParent(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isBlock(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node2.expectedNode || "Declaration" === node2.expectedNode || "BlockStatement" === node2.expectedNode)) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTerminatorless(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isCompletionStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isConditional(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ConditionalExpression" === nodeType || "IfStatement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isLoop(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isWhile(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("DoWhileStatement" === nodeType || "WhileStatement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExpressionWrapper(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFor(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isForXStatement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ForInStatement" === nodeType || "ForOfStatement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFunction(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFunctionParent(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPureish(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isDeclaration2(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || nodeType === "Placeholder" && "Declaration" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPatternLike(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSAsExpression" === nodeType || "TSSatisfiesExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Pattern" === node2.expectedNode || "Identifier" === node2.expectedNode)) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isLVal(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType || "TSAsExpression" === nodeType || "TSSatisfiesExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Pattern" === node2.expectedNode || "Identifier" === node2.expectedNode)) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSEntityName(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("Identifier" === nodeType || "TSQualifiedName" === nodeType || nodeType === "Placeholder" && "Identifier" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isLiteral(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImmutable(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "BigIntLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isUserWhitespacable(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isMethod(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ObjectMethod" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isObjectMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isProperty(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassAccessorProperty" === nodeType || "ClassPrivateProperty" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isUnaryLike(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("UnaryExpression" === nodeType || "SpreadElement" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPattern(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && "Pattern" === node2.expectedNode) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isClass(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ClassExpression" === nodeType || "ClassDeclaration" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isImportOrExportDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isExportDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isModuleSpecifier(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isAccessor(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ClassAccessorProperty" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isPrivate(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFlow(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType || "EnumDeclaration" === nodeType || "EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType || "EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFlowType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFlowBaseAnnotation(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFlowDeclaration(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isFlowPredicate(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumBody(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isEnumMember(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isJSX(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isMiscellaneous(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("Noop" === nodeType || "Placeholder" === nodeType || "V8IntrinsicIdentifier" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTypeScript(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("TSParameterProperty" === nodeType || "TSDeclareFunction" === nodeType || "TSDeclareMethod" === nodeType || "TSQualifiedName" === nodeType || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType || "TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSNamedTupleMember" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSInterfaceBody" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSSatisfiesExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSEnumDeclaration" === nodeType || "TSEnumMember" === nodeType || "TSModuleDeclaration" === nodeType || "TSModuleBlock" === nodeType || "TSImportType" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExternalModuleReference" === nodeType || "TSNonNullExpression" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || "TSTypeAnnotation" === nodeType || "TSTypeParameterInstantiation" === nodeType || "TSTypeParameterDeclaration" === nodeType || "TSTypeParameter" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSTypeElement(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSImportType" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isTSBaseType(node2, opts) {
      if (!node2)
        return false;
      const nodeType = node2.type;
      if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSLiteralType" === nodeType) {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isNumberLiteral(node2, opts) {
      (0, _deprecationWarning.default)("isNumberLiteral", "isNumericLiteral");
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "NumberLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isRegexLiteral(node2, opts) {
      (0, _deprecationWarning.default)("isRegexLiteral", "isRegExpLiteral");
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "RegexLiteral") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isRestProperty(node2, opts) {
      (0, _deprecationWarning.default)("isRestProperty", "isRestElement");
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "RestProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isSpreadProperty(node2, opts) {
      (0, _deprecationWarning.default)("isSpreadProperty", "isSpreadElement");
      if (!node2)
        return false;
      const nodeType = node2.type;
      if (nodeType === "SpreadProperty") {
        if (typeof opts === "undefined") {
          return true;
        } else {
          return (0, _shallowEqual.default)(node2, opts);
        }
      }
      return false;
    }
    function isModuleDeclaration(node2, opts) {
      (0, _deprecationWarning.default)("isModuleDeclaration", "isImportOrExportDeclaration");
      return isImportOrExportDeclaration(node2, opts);
    }
  }
});

// node_modules/@babel/types/lib/validators/matchesPattern.js
var require_matchesPattern = __commonJS({
  "node_modules/@babel/types/lib/validators/matchesPattern.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = matchesPattern;
    var _generated = require_generated();
    function matchesPattern(member, match, allowPartial) {
      if (!(0, _generated.isMemberExpression)(member))
        return false;
      const parts = Array.isArray(match) ? match : match.split(".");
      const nodes = [];
      let node2;
      for (node2 = member; (0, _generated.isMemberExpression)(node2); node2 = node2.object) {
        nodes.push(node2.property);
      }
      nodes.push(node2);
      if (nodes.length < parts.length)
        return false;
      if (!allowPartial && nodes.length > parts.length)
        return false;
      for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
        const node3 = nodes[j];
        let value2;
        if ((0, _generated.isIdentifier)(node3)) {
          value2 = node3.name;
        } else if ((0, _generated.isStringLiteral)(node3)) {
          value2 = node3.value;
        } else if ((0, _generated.isThisExpression)(node3)) {
          value2 = "this";
        } else {
          return false;
        }
        if (parts[i] !== value2)
          return false;
      }
      return true;
    }
  }
});

// node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js
var require_buildMatchMemberExpression = __commonJS({
  "node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = buildMatchMemberExpression;
    var _matchesPattern = require_matchesPattern();
    function buildMatchMemberExpression(match, allowPartial) {
      const parts = match.split(".");
      return (member) => (0, _matchesPattern.default)(member, parts, allowPartial);
    }
  }
});

// node_modules/@babel/types/lib/validators/react/isReactComponent.js
var require_isReactComponent = __commonJS({
  "node_modules/@babel/types/lib/validators/react/isReactComponent.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _buildMatchMemberExpression = require_buildMatchMemberExpression();
    var isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
    var _default = isReactComponent;
    exports.default = _default;
  }
});

// node_modules/@babel/types/lib/validators/react/isCompatTag.js
var require_isCompatTag = __commonJS({
  "node_modules/@babel/types/lib/validators/react/isCompatTag.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isCompatTag;
    function isCompatTag(tagName) {
      return !!tagName && /^[a-z]/.test(tagName);
    }
  }
});

// node_modules/to-fast-properties/index.js
var require_to_fast_properties = __commonJS({
  "node_modules/to-fast-properties/index.js"(exports, module2) {
    "use strict";
    var fastProto = null;
    function FastObject(o) {
      if (fastProto !== null && typeof fastProto.property) {
        const result = fastProto;
        fastProto = FastObject.prototype = null;
        return result;
      }
      fastProto = FastObject.prototype = o == null ? /* @__PURE__ */ Object.create(null) : o;
      return new FastObject();
    }
    FastObject();
    module2.exports = function toFastproperties(o) {
      return FastObject(o);
    };
  }
});

// node_modules/@babel/types/lib/validators/isType.js
var require_isType = __commonJS({
  "node_modules/@babel/types/lib/validators/isType.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isType;
    var _definitions = require_definitions();
    function isType(nodeType, targetType) {
      if (nodeType === targetType)
        return true;
      if (_definitions.ALIAS_KEYS[targetType])
        return false;
      const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
      if (aliases) {
        if (aliases[0] === nodeType)
          return true;
        for (const alias of aliases) {
          if (nodeType === alias)
            return true;
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/types/lib/validators/isPlaceholderType.js
var require_isPlaceholderType = __commonJS({
  "node_modules/@babel/types/lib/validators/isPlaceholderType.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isPlaceholderType;
    var _definitions = require_definitions();
    function isPlaceholderType(placeholderType, targetType) {
      if (placeholderType === targetType)
        return true;
      const aliases = _definitions.PLACEHOLDERS_ALIAS[placeholderType];
      if (aliases) {
        for (const alias of aliases) {
          if (targetType === alias)
            return true;
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/types/lib/validators/is.js
var require_is = __commonJS({
  "node_modules/@babel/types/lib/validators/is.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = is2;
    var _shallowEqual = require_shallowEqual();
    var _isType = require_isType();
    var _isPlaceholderType = require_isPlaceholderType();
    var _definitions = require_definitions();
    function is2(type, node2, opts) {
      if (!node2)
        return false;
      const matches = (0, _isType.default)(node2.type, type);
      if (!matches) {
        if (!opts && node2.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) {
          return (0, _isPlaceholderType.default)(node2.expectedNode, type);
        }
        return false;
      }
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node2, opts);
      }
    }
  }
});

// node_modules/@babel/helper-validator-identifier/lib/identifier.js
var require_identifier = __commonJS({
  "node_modules/@babel/helper-validator-identifier/lib/identifier.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isIdentifierChar = isIdentifierChar3;
    exports.isIdentifierName = isIdentifierName;
    exports.isIdentifierStart = isIdentifierStart3;
    var nonASCIIidentifierStartChars3 = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
    var nonASCIIidentifierChars3 = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
    var nonASCIIidentifierStart3 = new RegExp("[" + nonASCIIidentifierStartChars3 + "]");
    var nonASCIIidentifier3 = new RegExp("[" + nonASCIIidentifierStartChars3 + nonASCIIidentifierChars3 + "]");
    nonASCIIidentifierStartChars3 = nonASCIIidentifierChars3 = null;
    var astralIdentifierStartCodes3 = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191];
    var astralIdentifierCodes3 = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
    function isInAstralSet3(code2, set) {
      let pos2 = 65536;
      for (let i = 0, length = set.length; i < length; i += 2) {
        pos2 += set[i];
        if (pos2 > code2)
          return false;
        pos2 += set[i + 1];
        if (pos2 >= code2)
          return true;
      }
      return false;
    }
    function isIdentifierStart3(code2) {
      if (code2 < 65)
        return code2 === 36;
      if (code2 <= 90)
        return true;
      if (code2 < 97)
        return code2 === 95;
      if (code2 <= 122)
        return true;
      if (code2 <= 65535) {
        return code2 >= 170 && nonASCIIidentifierStart3.test(String.fromCharCode(code2));
      }
      return isInAstralSet3(code2, astralIdentifierStartCodes3);
    }
    function isIdentifierChar3(code2) {
      if (code2 < 48)
        return code2 === 36;
      if (code2 < 58)
        return true;
      if (code2 < 65)
        return false;
      if (code2 <= 90)
        return true;
      if (code2 < 97)
        return code2 === 95;
      if (code2 <= 122)
        return true;
      if (code2 <= 65535) {
        return code2 >= 170 && nonASCIIidentifier3.test(String.fromCharCode(code2));
      }
      return isInAstralSet3(code2, astralIdentifierStartCodes3) || isInAstralSet3(code2, astralIdentifierCodes3);
    }
    function isIdentifierName(name2) {
      let isFirst = true;
      for (let i = 0; i < name2.length; i++) {
        let cp = name2.charCodeAt(i);
        if ((cp & 64512) === 55296 && i + 1 < name2.length) {
          const trail = name2.charCodeAt(++i);
          if ((trail & 64512) === 56320) {
            cp = 65536 + ((cp & 1023) << 10) + (trail & 1023);
          }
        }
        if (isFirst) {
          isFirst = false;
          if (!isIdentifierStart3(cp)) {
            return false;
          }
        } else if (!isIdentifierChar3(cp)) {
          return false;
        }
      }
      return !isFirst;
    }
  }
});

// node_modules/@babel/helper-validator-identifier/lib/keyword.js
var require_keyword = __commonJS({
  "node_modules/@babel/helper-validator-identifier/lib/keyword.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isKeyword = isKeyword;
    exports.isReservedWord = isReservedWord;
    exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
    exports.isStrictBindReservedWord = isStrictBindReservedWord;
    exports.isStrictReservedWord = isStrictReservedWord;
    var reservedWords3 = {
      keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
      strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
      strictBind: ["eval", "arguments"]
    };
    var keywords3 = new Set(reservedWords3.keyword);
    var reservedWordsStrictSet = new Set(reservedWords3.strict);
    var reservedWordsStrictBindSet = new Set(reservedWords3.strictBind);
    function isReservedWord(word, inModule) {
      return inModule && word === "await" || word === "enum";
    }
    function isStrictReservedWord(word, inModule) {
      return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
    }
    function isStrictBindOnlyReservedWord(word) {
      return reservedWordsStrictBindSet.has(word);
    }
    function isStrictBindReservedWord(word, inModule) {
      return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
    }
    function isKeyword(word) {
      return keywords3.has(word);
    }
  }
});

// node_modules/@babel/helper-validator-identifier/lib/index.js
var require_lib = __commonJS({
  "node_modules/@babel/helper-validator-identifier/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "isIdentifierChar", {
      enumerable: true,
      get: function() {
        return _identifier.isIdentifierChar;
      }
    });
    Object.defineProperty(exports, "isIdentifierName", {
      enumerable: true,
      get: function() {
        return _identifier.isIdentifierName;
      }
    });
    Object.defineProperty(exports, "isIdentifierStart", {
      enumerable: true,
      get: function() {
        return _identifier.isIdentifierStart;
      }
    });
    Object.defineProperty(exports, "isKeyword", {
      enumerable: true,
      get: function() {
        return _keyword.isKeyword;
      }
    });
    Object.defineProperty(exports, "isReservedWord", {
      enumerable: true,
      get: function() {
        return _keyword.isReservedWord;
      }
    });
    Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
      enumerable: true,
      get: function() {
        return _keyword.isStrictBindOnlyReservedWord;
      }
    });
    Object.defineProperty(exports, "isStrictBindReservedWord", {
      enumerable: true,
      get: function() {
        return _keyword.isStrictBindReservedWord;
      }
    });
    Object.defineProperty(exports, "isStrictReservedWord", {
      enumerable: true,
      get: function() {
        return _keyword.isStrictReservedWord;
      }
    });
    var _identifier = require_identifier();
    var _keyword = require_keyword();
  }
});

// node_modules/@babel/types/lib/validators/isValidIdentifier.js
var require_isValidIdentifier = __commonJS({
  "node_modules/@babel/types/lib/validators/isValidIdentifier.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isValidIdentifier;
    var _helperValidatorIdentifier = require_lib();
    function isValidIdentifier(name2, reserved = true) {
      if (typeof name2 !== "string")
        return false;
      if (reserved) {
        if ((0, _helperValidatorIdentifier.isKeyword)(name2) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name2, true)) {
          return false;
        }
      }
      return (0, _helperValidatorIdentifier.isIdentifierName)(name2);
    }
  }
});

// node_modules/@babel/helper-string-parser/lib/index.js
var require_lib2 = __commonJS({
  "node_modules/@babel/helper-string-parser/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.readCodePoint = readCodePoint;
    exports.readInt = readInt;
    exports.readStringContents = readStringContents;
    var _isDigit = function isDigit(code2) {
      return code2 >= 48 && code2 <= 57;
    };
    var forbiddenNumericSeparatorSiblings = {
      decBinOct: /* @__PURE__ */ new Set([46, 66, 69, 79, 95, 98, 101, 111]),
      hex: /* @__PURE__ */ new Set([46, 88, 95, 120])
    };
    var isAllowedNumericSeparatorSibling = {
      bin: (ch) => ch === 48 || ch === 49,
      oct: (ch) => ch >= 48 && ch <= 55,
      dec: (ch) => ch >= 48 && ch <= 57,
      hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
    };
    function readStringContents(type, input, pos2, lineStart, curLine, errors) {
      const initialPos = pos2;
      const initialLineStart = lineStart;
      const initialCurLine = curLine;
      let out = "";
      let firstInvalidLoc = null;
      let chunkStart = pos2;
      const {
        length
      } = input;
      for (; ; ) {
        if (pos2 >= length) {
          errors.unterminated(initialPos, initialLineStart, initialCurLine);
          out += input.slice(chunkStart, pos2);
          break;
        }
        const ch = input.charCodeAt(pos2);
        if (isStringEnd(type, ch, input, pos2)) {
          out += input.slice(chunkStart, pos2);
          break;
        }
        if (ch === 92) {
          out += input.slice(chunkStart, pos2);
          const res = readEscapedChar(input, pos2, lineStart, curLine, type === "template", errors);
          if (res.ch === null && !firstInvalidLoc) {
            firstInvalidLoc = {
              pos: pos2,
              lineStart,
              curLine
            };
          } else {
            out += res.ch;
          }
          ({
            pos: pos2,
            lineStart,
            curLine
          } = res);
          chunkStart = pos2;
        } else if (ch === 8232 || ch === 8233) {
          ++pos2;
          ++curLine;
          lineStart = pos2;
        } else if (ch === 10 || ch === 13) {
          if (type === "template") {
            out += input.slice(chunkStart, pos2) + "\n";
            ++pos2;
            if (ch === 13 && input.charCodeAt(pos2) === 10) {
              ++pos2;
            }
            ++curLine;
            chunkStart = lineStart = pos2;
          } else {
            errors.unterminated(initialPos, initialLineStart, initialCurLine);
          }
        } else {
          ++pos2;
        }
      }
      return {
        pos: pos2,
        str: out,
        firstInvalidLoc,
        lineStart,
        curLine,
        containsInvalid: !!firstInvalidLoc
      };
    }
    function isStringEnd(type, ch, input, pos2) {
      if (type === "template") {
        return ch === 96 || ch === 36 && input.charCodeAt(pos2 + 1) === 123;
      }
      return ch === (type === "double" ? 34 : 39);
    }
    function readEscapedChar(input, pos2, lineStart, curLine, inTemplate, errors) {
      const throwOnInvalid = !inTemplate;
      pos2++;
      const res = (ch2) => ({
        pos: pos2,
        ch: ch2,
        lineStart,
        curLine
      });
      const ch = input.charCodeAt(pos2++);
      switch (ch) {
        case 110:
          return res("\n");
        case 114:
          return res("\r");
        case 120: {
          let code2;
          ({
            code: code2,
            pos: pos2
          } = readHexChar(input, pos2, lineStart, curLine, 2, false, throwOnInvalid, errors));
          return res(code2 === null ? null : String.fromCharCode(code2));
        }
        case 117: {
          let code2;
          ({
            code: code2,
            pos: pos2
          } = readCodePoint(input, pos2, lineStart, curLine, throwOnInvalid, errors));
          return res(code2 === null ? null : String.fromCodePoint(code2));
        }
        case 116:
          return res("	");
        case 98:
          return res("\b");
        case 118:
          return res("\v");
        case 102:
          return res("\f");
        case 13:
          if (input.charCodeAt(pos2) === 10) {
            ++pos2;
          }
        case 10:
          lineStart = pos2;
          ++curLine;
        case 8232:
        case 8233:
          return res("");
        case 56:
        case 57:
          if (inTemplate) {
            return res(null);
          } else {
            errors.strictNumericEscape(pos2 - 1, lineStart, curLine);
          }
        default:
          if (ch >= 48 && ch <= 55) {
            const startPos = pos2 - 1;
            const match = input.slice(startPos, pos2 + 2).match(/^[0-7]+/);
            let octalStr = match[0];
            let octal = parseInt(octalStr, 8);
            if (octal > 255) {
              octalStr = octalStr.slice(0, -1);
              octal = parseInt(octalStr, 8);
            }
            pos2 += octalStr.length - 1;
            const next = input.charCodeAt(pos2);
            if (octalStr !== "0" || next === 56 || next === 57) {
              if (inTemplate) {
                return res(null);
              } else {
                errors.strictNumericEscape(startPos, lineStart, curLine);
              }
            }
            return res(String.fromCharCode(octal));
          }
          return res(String.fromCharCode(ch));
      }
    }
    function readHexChar(input, pos2, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
      const initialPos = pos2;
      let n;
      ({
        n,
        pos: pos2
      } = readInt(input, pos2, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
      if (n === null) {
        if (throwOnInvalid) {
          errors.invalidEscapeSequence(initialPos, lineStart, curLine);
        } else {
          pos2 = initialPos - 1;
        }
      }
      return {
        code: n,
        pos: pos2
      };
    }
    function readInt(input, pos2, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
      const start3 = pos2;
      const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
      const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
      let invalid2 = false;
      let total = 0;
      for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
        const code2 = input.charCodeAt(pos2);
        let val;
        if (code2 === 95 && allowNumSeparator !== "bail") {
          const prev = input.charCodeAt(pos2 - 1);
          const next = input.charCodeAt(pos2 + 1);
          if (!allowNumSeparator) {
            if (bailOnError)
              return {
                n: null,
                pos: pos2
              };
            errors.numericSeparatorInEscapeSequence(pos2, lineStart, curLine);
          } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
            if (bailOnError)
              return {
                n: null,
                pos: pos2
              };
            errors.unexpectedNumericSeparator(pos2, lineStart, curLine);
          }
          ++pos2;
          continue;
        }
        if (code2 >= 97) {
          val = code2 - 97 + 10;
        } else if (code2 >= 65) {
          val = code2 - 65 + 10;
        } else if (_isDigit(code2)) {
          val = code2 - 48;
        } else {
          val = Infinity;
        }
        if (val >= radix) {
          if (val <= 9 && bailOnError) {
            return {
              n: null,
              pos: pos2
            };
          } else if (val <= 9 && errors.invalidDigit(pos2, lineStart, curLine, radix)) {
            val = 0;
          } else if (forceLen) {
            val = 0;
            invalid2 = true;
          } else {
            break;
          }
        }
        ++pos2;
        total = total * radix + val;
      }
      if (pos2 === start3 || len != null && pos2 - start3 !== len || invalid2) {
        return {
          n: null,
          pos: pos2
        };
      }
      return {
        n: total,
        pos: pos2
      };
    }
    function readCodePoint(input, pos2, lineStart, curLine, throwOnInvalid, errors) {
      const ch = input.charCodeAt(pos2);
      let code2;
      if (ch === 123) {
        ++pos2;
        ({
          code: code2,
          pos: pos2
        } = readHexChar(input, pos2, lineStart, curLine, input.indexOf("}", pos2) - pos2, true, throwOnInvalid, errors));
        ++pos2;
        if (code2 !== null && code2 > 1114111) {
          if (throwOnInvalid) {
            errors.invalidCodePoint(pos2, lineStart, curLine);
          } else {
            return {
              code: null,
              pos: pos2
            };
          }
        }
      } else {
        ({
          code: code2,
          pos: pos2
        } = readHexChar(input, pos2, lineStart, curLine, 4, false, throwOnInvalid, errors));
      }
      return {
        code: code2,
        pos: pos2
      };
    }
  }
});

// node_modules/@babel/types/lib/constants/index.js
var require_constants = __commonJS({
  "node_modules/@babel/types/lib/constants/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;
    var STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
    exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
    var FLATTENABLE_KEYS = ["body", "expressions"];
    exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
    var FOR_INIT_KEYS = ["left", "init"];
    exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
    var COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
    exports.COMMENT_KEYS = COMMENT_KEYS;
    var LOGICAL_OPERATORS = ["||", "&&", "??"];
    exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
    var UPDATE_OPERATORS = ["++", "--"];
    exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
    var BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
    exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
    var EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
    exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
    var COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
    exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
    var BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
    exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
    var NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
    exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
    var BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
    exports.BINARY_OPERATORS = BINARY_OPERATORS;
    var ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map((op) => op + "="), ...LOGICAL_OPERATORS.map((op) => op + "=")];
    exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
    var BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
    exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
    var NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
    exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
    var STRING_UNARY_OPERATORS = ["typeof"];
    exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
    var UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
    exports.UNARY_OPERATORS = UNARY_OPERATORS;
    var INHERIT_KEYS = {
      optional: ["typeAnnotation", "typeParameters", "returnType"],
      force: ["start", "loc", "end"]
    };
    exports.INHERIT_KEYS = INHERIT_KEYS;
    var BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
    exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
    var NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
    exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
  }
});

// node_modules/@babel/types/lib/definitions/utils.js
var require_utils = __commonJS({
  "node_modules/@babel/types/lib/definitions/utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.VISITOR_KEYS = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0;
    exports.arrayOf = arrayOf;
    exports.arrayOfType = arrayOfType;
    exports.assertEach = assertEach;
    exports.assertNodeOrValueType = assertNodeOrValueType;
    exports.assertNodeType = assertNodeType;
    exports.assertOneOf = assertOneOf;
    exports.assertOptionalChainStart = assertOptionalChainStart;
    exports.assertShape = assertShape;
    exports.assertValueType = assertValueType;
    exports.chain = chain;
    exports.default = defineType;
    exports.defineAliasedType = defineAliasedType;
    exports.typeIs = typeIs;
    exports.validate = validate;
    exports.validateArrayOfType = validateArrayOfType;
    exports.validateOptional = validateOptional;
    exports.validateOptionalType = validateOptionalType;
    exports.validateType = validateType;
    var _is = require_is();
    var _validate = require_validate();
    var VISITOR_KEYS = {};
    exports.VISITOR_KEYS = VISITOR_KEYS;
    var ALIAS_KEYS = {};
    exports.ALIAS_KEYS = ALIAS_KEYS;
    var FLIPPED_ALIAS_KEYS = {};
    exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
    var NODE_FIELDS = {};
    exports.NODE_FIELDS = NODE_FIELDS;
    var BUILDER_KEYS = {};
    exports.BUILDER_KEYS = BUILDER_KEYS;
    var DEPRECATED_KEYS = {};
    exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
    var NODE_PARENT_VALIDATIONS = {};
    exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
    function getType(val) {
      if (Array.isArray(val)) {
        return "array";
      } else if (val === null) {
        return "null";
      } else {
        return typeof val;
      }
    }
    function validate(validate2) {
      return {
        validate: validate2
      };
    }
    function typeIs(typeName) {
      return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
    }
    function validateType(typeName) {
      return validate(typeIs(typeName));
    }
    function validateOptional(validate2) {
      return {
        validate: validate2,
        optional: true
      };
    }
    function validateOptionalType(typeName) {
      return {
        validate: typeIs(typeName),
        optional: true
      };
    }
    function arrayOf(elementType) {
      return chain(assertValueType("array"), assertEach(elementType));
    }
    function arrayOfType(typeName) {
      return arrayOf(typeIs(typeName));
    }
    function validateArrayOfType(typeName) {
      return validate(arrayOfType(typeName));
    }
    function assertEach(callback) {
      function validator(node2, key2, val) {
        if (!Array.isArray(val))
          return;
        for (let i = 0; i < val.length; i++) {
          const subkey = `${key2}[${i}]`;
          const v = val[i];
          callback(node2, subkey, v);
          if (process.env.BABEL_TYPES_8_BREAKING)
            (0, _validate.validateChild)(node2, subkey, v);
        }
      }
      validator.each = callback;
      return validator;
    }
    function assertOneOf(...values) {
      function validate2(node2, key2, val) {
        if (values.indexOf(val) < 0) {
          throw new TypeError(`Property ${key2} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
        }
      }
      validate2.oneOf = values;
      return validate2;
    }
    function assertNodeType(...types3) {
      function validate2(node2, key2, val) {
        for (const type of types3) {
          if ((0, _is.default)(type, val)) {
            (0, _validate.validateChild)(node2, key2, val);
            return;
          }
        }
        throw new TypeError(`Property ${key2} of ${node2.type} expected node to be of a type ${JSON.stringify(types3)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
      }
      validate2.oneOfNodeTypes = types3;
      return validate2;
    }
    function assertNodeOrValueType(...types3) {
      function validate2(node2, key2, val) {
        for (const type of types3) {
          if (getType(val) === type || (0, _is.default)(type, val)) {
            (0, _validate.validateChild)(node2, key2, val);
            return;
          }
        }
        throw new TypeError(`Property ${key2} of ${node2.type} expected node to be of a type ${JSON.stringify(types3)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
      }
      validate2.oneOfNodeOrValueTypes = types3;
      return validate2;
    }
    function assertValueType(type) {
      function validate2(node2, key2, val) {
        const valid2 = getType(val) === type;
        if (!valid2) {
          throw new TypeError(`Property ${key2} expected type of ${type} but got ${getType(val)}`);
        }
      }
      validate2.type = type;
      return validate2;
    }
    function assertShape(shape) {
      function validate2(node2, key2, val) {
        const errors = [];
        for (const property of Object.keys(shape)) {
          try {
            (0, _validate.validateField)(node2, property, val[property], shape[property]);
          } catch (error) {
            if (error instanceof TypeError) {
              errors.push(error.message);
              continue;
            }
            throw error;
          }
        }
        if (errors.length) {
          throw new TypeError(`Property ${key2} of ${node2.type} expected to have the following:
${errors.join("\n")}`);
        }
      }
      validate2.shapeOf = shape;
      return validate2;
    }
    function assertOptionalChainStart() {
      function validate2(node2) {
        var _current;
        let current3 = node2;
        while (node2) {
          const {
            type
          } = current3;
          if (type === "OptionalCallExpression") {
            if (current3.optional)
              return;
            current3 = current3.callee;
            continue;
          }
          if (type === "OptionalMemberExpression") {
            if (current3.optional)
              return;
            current3 = current3.object;
            continue;
          }
          break;
        }
        throw new TypeError(`Non-optional ${node2.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current3) == null ? void 0 : _current.type}`);
      }
      return validate2;
    }
    function chain(...fns) {
      function validate2(...args) {
        for (const fn of fns) {
          fn(...args);
        }
      }
      validate2.chainOf = fns;
      if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
        throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
      }
      return validate2;
    }
    var validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
    var validFieldKeys = ["default", "optional", "validate"];
    var store = {};
    function defineAliasedType(...aliases) {
      return (type, opts = {}) => {
        let defined = opts.aliases;
        if (!defined) {
          var _store$opts$inherits$, _defined;
          if (opts.inherits)
            defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice();
          (_defined = defined) != null ? _defined : defined = [];
          opts.aliases = defined;
        }
        const additional = aliases.filter((a) => !defined.includes(a));
        defined.unshift(...additional);
        defineType(type, opts);
      };
    }
    function defineType(type, opts = {}) {
      const inherits = opts.inherits && store[opts.inherits] || {};
      let fields = opts.fields;
      if (!fields) {
        fields = {};
        if (inherits.fields) {
          const keys2 = Object.getOwnPropertyNames(inherits.fields);
          for (const key2 of keys2) {
            const field = inherits.fields[key2];
            const def = field.default;
            if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
              throw new Error("field defaults can only be primitives or empty arrays currently");
            }
            fields[key2] = {
              default: Array.isArray(def) ? [] : def,
              optional: field.optional,
              validate: field.validate
            };
          }
        }
      }
      const visitor = opts.visitor || inherits.visitor || [];
      const aliases = opts.aliases || inherits.aliases || [];
      const builder = opts.builder || inherits.builder || opts.visitor || [];
      for (const k of Object.keys(opts)) {
        if (validTypeOpts.indexOf(k) === -1) {
          throw new Error(`Unknown type option "${k}" on ${type}`);
        }
      }
      if (opts.deprecatedAlias) {
        DEPRECATED_KEYS[opts.deprecatedAlias] = type;
      }
      for (const key2 of visitor.concat(builder)) {
        fields[key2] = fields[key2] || {};
      }
      for (const key2 of Object.keys(fields)) {
        const field = fields[key2];
        if (field.default !== void 0 && builder.indexOf(key2) === -1) {
          field.optional = true;
        }
        if (field.default === void 0) {
          field.default = null;
        } else if (!field.validate && field.default != null) {
          field.validate = assertValueType(getType(field.default));
        }
        for (const k of Object.keys(field)) {
          if (validFieldKeys.indexOf(k) === -1) {
            throw new Error(`Unknown field key "${k}" on ${type}.${key2}`);
          }
        }
      }
      VISITOR_KEYS[type] = opts.visitor = visitor;
      BUILDER_KEYS[type] = opts.builder = builder;
      NODE_FIELDS[type] = opts.fields = fields;
      ALIAS_KEYS[type] = opts.aliases = aliases;
      aliases.forEach((alias) => {
        FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
        FLIPPED_ALIAS_KEYS[alias].push(type);
      });
      if (opts.validate) {
        NODE_PARENT_VALIDATIONS[type] = opts.validate;
      }
      store[type] = opts;
    }
  }
});

// node_modules/@babel/types/lib/definitions/core.js
var require_core = __commonJS({
  "node_modules/@babel/types/lib/definitions/core.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.patternLikeCommon = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0;
    var _is = require_is();
    var _isValidIdentifier = require_isValidIdentifier();
    var _helperValidatorIdentifier = require_lib();
    var _helperStringParser = require_lib2();
    var _constants = require_constants();
    var _utils = require_utils();
    var defineType = (0, _utils.defineAliasedType)("Standardized");
    defineType("ArrayExpression", {
      fields: {
        elements: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
          default: !process.env.BABEL_TYPES_8_BREAKING ? [] : void 0
        }
      },
      visitor: ["elements"],
      aliases: ["Expression"]
    });
    defineType("AssignmentExpression", {
      fields: {
        operator: {
          validate: function() {
            if (!process.env.BABEL_TYPES_8_BREAKING) {
              return (0, _utils.assertValueType)("string");
            }
            const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
            const pattern = (0, _utils.assertOneOf)("=");
            return function(node2, key2, val) {
              const validator = (0, _is.default)("Pattern", node2.left) ? pattern : identifier;
              validator(node2, key2, val);
            };
          }()
        },
        left: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
        },
        right: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      },
      builder: ["operator", "left", "right"],
      visitor: ["left", "right"],
      aliases: ["Expression"]
    });
    defineType("BinaryExpression", {
      builder: ["operator", "left", "right"],
      fields: {
        operator: {
          validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
        },
        left: {
          validate: function() {
            const expression = (0, _utils.assertNodeType)("Expression");
            const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
            const validator = Object.assign(function(node2, key2, val) {
              const validator2 = node2.operator === "in" ? inOp : expression;
              validator2(node2, key2, val);
            }, {
              oneOfNodeTypes: ["Expression", "PrivateName"]
            });
            return validator;
          }()
        },
        right: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      },
      visitor: ["left", "right"],
      aliases: ["Binary", "Expression"]
    });
    defineType("InterpreterDirective", {
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("string")
        }
      }
    });
    defineType("Directive", {
      visitor: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertNodeType)("DirectiveLiteral")
        }
      }
    });
    defineType("DirectiveLiteral", {
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("string")
        }
      }
    });
    defineType("BlockStatement", {
      builder: ["body", "directives"],
      visitor: ["directives", "body"],
      fields: {
        directives: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
          default: []
        },
        body: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
        }
      },
      aliases: ["Scopable", "BlockParent", "Block", "Statement"]
    });
    defineType("BreakStatement", {
      visitor: ["label"],
      fields: {
        label: {
          validate: (0, _utils.assertNodeType)("Identifier"),
          optional: true
        }
      },
      aliases: ["Statement", "Terminatorless", "CompletionStatement"]
    });
    defineType("CallExpression", {
      visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
      builder: ["callee", "arguments"],
      aliases: ["Expression"],
      fields: Object.assign({
        callee: {
          validate: (0, _utils.assertNodeType)("Expression", "Super", "V8IntrinsicIdentifier")
        },
        arguments: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
        }
      }, !process.env.BABEL_TYPES_8_BREAKING ? {
        optional: {
          validate: (0, _utils.assertOneOf)(true, false),
          optional: true
        }
      } : {}, {
        typeArguments: {
          validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
          optional: true
        },
        typeParameters: {
          validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
          optional: true
        }
      })
    });
    defineType("CatchClause", {
      visitor: ["param", "body"],
      fields: {
        param: {
          validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
          optional: true
        },
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        }
      },
      aliases: ["Scopable", "BlockParent"]
    });
    defineType("ConditionalExpression", {
      visitor: ["test", "consequent", "alternate"],
      fields: {
        test: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        consequent: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        alternate: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      },
      aliases: ["Expression", "Conditional"]
    });
    defineType("ContinueStatement", {
      visitor: ["label"],
      fields: {
        label: {
          validate: (0, _utils.assertNodeType)("Identifier"),
          optional: true
        }
      },
      aliases: ["Statement", "Terminatorless", "CompletionStatement"]
    });
    defineType("DebuggerStatement", {
      aliases: ["Statement"]
    });
    defineType("DoWhileStatement", {
      visitor: ["test", "body"],
      fields: {
        test: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        }
      },
      aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
    });
    defineType("EmptyStatement", {
      aliases: ["Statement"]
    });
    defineType("ExpressionStatement", {
      visitor: ["expression"],
      fields: {
        expression: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      },
      aliases: ["Statement", "ExpressionWrapper"]
    });
    defineType("File", {
      builder: ["program", "comments", "tokens"],
      visitor: ["program"],
      fields: {
        program: {
          validate: (0, _utils.assertNodeType)("Program")
        },
        comments: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {
          }, {
            each: {
              oneOfNodeTypes: ["CommentBlock", "CommentLine"]
            }
          }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
          optional: true
        },
        tokens: {
          validate: (0, _utils.assertEach)(Object.assign(() => {
          }, {
            type: "any"
          })),
          optional: true
        }
      }
    });
    defineType("ForInStatement", {
      visitor: ["left", "right", "body"],
      aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
      fields: {
        left: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
        },
        right: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        }
      }
    });
    defineType("ForStatement", {
      visitor: ["init", "test", "update", "body"],
      aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
      fields: {
        init: {
          validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
          optional: true
        },
        test: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        },
        update: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        }
      }
    });
    var functionCommon = () => ({
      params: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
      },
      generator: {
        default: false
      },
      async: {
        default: false
      }
    });
    exports.functionCommon = functionCommon;
    var functionTypeAnnotationCommon = () => ({
      returnType: {
        validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
        optional: true
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
        optional: true
      }
    });
    exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
    var functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
      declare: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      id: {
        validate: (0, _utils.assertNodeType)("Identifier"),
        optional: true
      }
    });
    exports.functionDeclarationCommon = functionDeclarationCommon;
    defineType("FunctionDeclaration", {
      builder: ["id", "params", "body", "generator", "async"],
      visitor: ["id", "params", "body", "returnType", "typeParameters"],
      fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), {
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        },
        predicate: {
          validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
          optional: true
        }
      }),
      aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
      validate: function() {
        if (!process.env.BABEL_TYPES_8_BREAKING)
          return () => {
          };
        const identifier = (0, _utils.assertNodeType)("Identifier");
        return function(parent, key2, node2) {
          if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
            identifier(node2, "id", node2.id);
          }
        };
      }()
    });
    defineType("FunctionExpression", {
      inherits: "FunctionDeclaration",
      aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
      fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
        id: {
          validate: (0, _utils.assertNodeType)("Identifier"),
          optional: true
        },
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        },
        predicate: {
          validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
          optional: true
        }
      })
    });
    var patternLikeCommon = () => ({
      typeAnnotation: {
        validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
        optional: true
      },
      optional: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      }
    });
    exports.patternLikeCommon = patternLikeCommon;
    defineType("Identifier", {
      builder: ["name"],
      visitor: ["typeAnnotation", "decorators"],
      aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
      fields: Object.assign({}, patternLikeCommon(), {
        name: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (!(0, _isValidIdentifier.default)(val, false)) {
              throw new TypeError(`"${val}" is not a valid identifier name`);
            }
          }, {
            type: "string"
          }))
        }
      }),
      validate(parent, key2, node2) {
        if (!process.env.BABEL_TYPES_8_BREAKING)
          return;
        const match = /\.(\w+)$/.exec(key2);
        if (!match)
          return;
        const [, parentKey] = match;
        const nonComp = {
          computed: false
        };
        if (parentKey === "property") {
          if ((0, _is.default)("MemberExpression", parent, nonComp))
            return;
          if ((0, _is.default)("OptionalMemberExpression", parent, nonComp))
            return;
        } else if (parentKey === "key") {
          if ((0, _is.default)("Property", parent, nonComp))
            return;
          if ((0, _is.default)("Method", parent, nonComp))
            return;
        } else if (parentKey === "exported") {
          if ((0, _is.default)("ExportSpecifier", parent))
            return;
        } else if (parentKey === "imported") {
          if ((0, _is.default)("ImportSpecifier", parent, {
            imported: node2
          }))
            return;
        } else if (parentKey === "meta") {
          if ((0, _is.default)("MetaProperty", parent, {
            meta: node2
          }))
            return;
        }
        if (((0, _helperValidatorIdentifier.isKeyword)(node2.name) || (0, _helperValidatorIdentifier.isReservedWord)(node2.name, false)) && node2.name !== "this") {
          throw new TypeError(`"${node2.name}" is not a valid identifier`);
        }
      }
    });
    defineType("IfStatement", {
      visitor: ["test", "consequent", "alternate"],
      aliases: ["Statement", "Conditional"],
      fields: {
        test: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        consequent: {
          validate: (0, _utils.assertNodeType)("Statement")
        },
        alternate: {
          optional: true,
          validate: (0, _utils.assertNodeType)("Statement")
        }
      }
    });
    defineType("LabeledStatement", {
      visitor: ["label", "body"],
      aliases: ["Statement"],
      fields: {
        label: {
          validate: (0, _utils.assertNodeType)("Identifier")
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        }
      }
    });
    defineType("StringLiteral", {
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("string")
        }
      },
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
    defineType("NumericLiteral", {
      builder: ["value"],
      deprecatedAlias: "NumberLiteral",
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("number")
        }
      },
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
    defineType("NullLiteral", {
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
    defineType("BooleanLiteral", {
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("boolean")
        }
      },
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
    defineType("RegExpLiteral", {
      builder: ["pattern", "flags"],
      deprecatedAlias: "RegexLiteral",
      aliases: ["Expression", "Pureish", "Literal"],
      fields: {
        pattern: {
          validate: (0, _utils.assertValueType)("string")
        },
        flags: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            const invalid2 = /[^gimsuy]/.exec(val);
            if (invalid2) {
              throw new TypeError(`"${invalid2[0]}" is not a valid RegExp flag`);
            }
          }, {
            type: "string"
          })),
          default: ""
        }
      }
    });
    defineType("LogicalExpression", {
      builder: ["operator", "left", "right"],
      visitor: ["left", "right"],
      aliases: ["Binary", "Expression"],
      fields: {
        operator: {
          validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
        },
        left: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        right: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("MemberExpression", {
      builder: ["object", "property", "computed", ...!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : []],
      visitor: ["object", "property"],
      aliases: ["Expression", "LVal"],
      fields: Object.assign({
        object: {
          validate: (0, _utils.assertNodeType)("Expression", "Super")
        },
        property: {
          validate: function() {
            const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
            const computed = (0, _utils.assertNodeType)("Expression");
            const validator = function(node2, key2, val) {
              const validator2 = node2.computed ? computed : normal;
              validator2(node2, key2, val);
            };
            validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
            return validator;
          }()
        },
        computed: {
          default: false
        }
      }, !process.env.BABEL_TYPES_8_BREAKING ? {
        optional: {
          validate: (0, _utils.assertOneOf)(true, false),
          optional: true
        }
      } : {})
    });
    defineType("NewExpression", {
      inherits: "CallExpression"
    });
    defineType("Program", {
      visitor: ["directives", "body"],
      builder: ["body", "directives", "sourceType", "interpreter"],
      fields: {
        sourceFile: {
          validate: (0, _utils.assertValueType)("string")
        },
        sourceType: {
          validate: (0, _utils.assertOneOf)("script", "module"),
          default: "script"
        },
        interpreter: {
          validate: (0, _utils.assertNodeType)("InterpreterDirective"),
          default: null,
          optional: true
        },
        directives: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
          default: []
        },
        body: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
        }
      },
      aliases: ["Scopable", "BlockParent", "Block"]
    });
    defineType("ObjectExpression", {
      visitor: ["properties"],
      aliases: ["Expression"],
      fields: {
        properties: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
        }
      }
    });
    defineType("ObjectMethod", {
      builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
      fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
        kind: Object.assign({
          validate: (0, _utils.assertOneOf)("method", "get", "set")
        }, !process.env.BABEL_TYPES_8_BREAKING ? {
          default: "method"
        } : {}),
        computed: {
          default: false
        },
        key: {
          validate: function() {
            const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
            const computed = (0, _utils.assertNodeType)("Expression");
            const validator = function(node2, key2, val) {
              const validator2 = node2.computed ? computed : normal;
              validator2(node2, key2, val);
            };
            validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"];
            return validator;
          }()
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        },
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        }
      }),
      visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
      aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
    });
    defineType("ObjectProperty", {
      builder: ["key", "value", "computed", "shorthand", ...!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : []],
      fields: {
        computed: {
          default: false
        },
        key: {
          validate: function() {
            const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName");
            const computed = (0, _utils.assertNodeType)("Expression");
            const validator = Object.assign(function(node2, key2, val) {
              const validator2 = node2.computed ? computed : normal;
              validator2(node2, key2, val);
            }, {
              oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"]
            });
            return validator;
          }()
        },
        value: {
          validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
        },
        shorthand: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (val && node2.computed) {
              throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
            }
          }, {
            type: "boolean"
          }), function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (val && !(0, _is.default)("Identifier", node2.key)) {
              throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
            }
          }),
          default: false
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        }
      },
      visitor: ["key", "value", "decorators"],
      aliases: ["UserWhitespacable", "Property", "ObjectMember"],
      validate: function() {
        const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion");
        const expression = (0, _utils.assertNodeType)("Expression");
        return function(parent, key2, node2) {
          if (!process.env.BABEL_TYPES_8_BREAKING)
            return;
          const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
          validator(node2, "value", node2.value);
        };
      }()
    });
    defineType("RestElement", {
      visitor: ["argument", "typeAnnotation"],
      builder: ["argument"],
      aliases: ["LVal", "PatternLike"],
      deprecatedAlias: "RestProperty",
      fields: Object.assign({}, patternLikeCommon(), {
        argument: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
        }
      }),
      validate(parent, key2) {
        if (!process.env.BABEL_TYPES_8_BREAKING)
          return;
        const match = /(\w+)\[(\d+)\]/.exec(key2);
        if (!match)
          throw new Error("Internal Babel error: malformed key.");
        const [, listKey, index2] = match;
        if (parent[listKey].length > +index2 + 1) {
          throw new TypeError(`RestElement must be last element of ${listKey}`);
        }
      }
    });
    defineType("ReturnStatement", {
      visitor: ["argument"],
      aliases: ["Statement", "Terminatorless", "CompletionStatement"],
      fields: {
        argument: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        }
      }
    });
    defineType("SequenceExpression", {
      visitor: ["expressions"],
      fields: {
        expressions: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
        }
      },
      aliases: ["Expression"]
    });
    defineType("ParenthesizedExpression", {
      visitor: ["expression"],
      aliases: ["Expression", "ExpressionWrapper"],
      fields: {
        expression: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("SwitchCase", {
      visitor: ["test", "consequent"],
      fields: {
        test: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        },
        consequent: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
        }
      }
    });
    defineType("SwitchStatement", {
      visitor: ["discriminant", "cases"],
      aliases: ["Statement", "BlockParent", "Scopable"],
      fields: {
        discriminant: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        cases: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
        }
      }
    });
    defineType("ThisExpression", {
      aliases: ["Expression"]
    });
    defineType("ThrowStatement", {
      visitor: ["argument"],
      aliases: ["Statement", "Terminatorless", "CompletionStatement"],
      fields: {
        argument: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("TryStatement", {
      visitor: ["block", "handler", "finalizer"],
      aliases: ["Statement"],
      fields: {
        block: {
          validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function(node2) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (!node2.handler && !node2.finalizer) {
              throw new TypeError("TryStatement expects either a handler or finalizer, or both");
            }
          }, {
            oneOfNodeTypes: ["BlockStatement"]
          }))
        },
        handler: {
          optional: true,
          validate: (0, _utils.assertNodeType)("CatchClause")
        },
        finalizer: {
          optional: true,
          validate: (0, _utils.assertNodeType)("BlockStatement")
        }
      }
    });
    defineType("UnaryExpression", {
      builder: ["operator", "argument", "prefix"],
      fields: {
        prefix: {
          default: true
        },
        argument: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        operator: {
          validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
        }
      },
      visitor: ["argument"],
      aliases: ["UnaryLike", "Expression"]
    });
    defineType("UpdateExpression", {
      builder: ["operator", "argument", "prefix"],
      fields: {
        prefix: {
          default: false
        },
        argument: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
        },
        operator: {
          validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
        }
      },
      visitor: ["argument"],
      aliases: ["Expression"]
    });
    defineType("VariableDeclaration", {
      builder: ["kind", "declarations"],
      visitor: ["declarations"],
      aliases: ["Statement", "Declaration"],
      fields: {
        declare: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        kind: {
          validate: (0, _utils.assertOneOf)("var", "let", "const", "using")
        },
        declarations: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
        }
      },
      validate(parent, key2, node2) {
        if (!process.env.BABEL_TYPES_8_BREAKING)
          return;
        if (!(0, _is.default)("ForXStatement", parent, {
          left: node2
        }))
          return;
        if (node2.declarations.length !== 1) {
          throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
        }
      }
    });
    defineType("VariableDeclarator", {
      visitor: ["id", "init"],
      fields: {
        id: {
          validate: function() {
            if (!process.env.BABEL_TYPES_8_BREAKING) {
              return (0, _utils.assertNodeType)("LVal");
            }
            const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
            const without = (0, _utils.assertNodeType)("Identifier");
            return function(node2, key2, val) {
              const validator = node2.init ? normal : without;
              validator(node2, key2, val);
            };
          }()
        },
        definite: {
          optional: true,
          validate: (0, _utils.assertValueType)("boolean")
        },
        init: {
          optional: true,
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("WhileStatement", {
      visitor: ["test", "body"],
      aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
      fields: {
        test: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        }
      }
    });
    defineType("WithStatement", {
      visitor: ["object", "body"],
      aliases: ["Statement"],
      fields: {
        object: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        }
      }
    });
    defineType("AssignmentPattern", {
      visitor: ["left", "right", "decorators"],
      builder: ["left", "right"],
      aliases: ["Pattern", "PatternLike", "LVal"],
      fields: Object.assign({}, patternLikeCommon(), {
        left: {
          validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
        },
        right: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        }
      })
    });
    defineType("ArrayPattern", {
      visitor: ["elements", "typeAnnotation"],
      builder: ["elements"],
      aliases: ["Pattern", "PatternLike", "LVal"],
      fields: Object.assign({}, patternLikeCommon(), {
        elements: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike", "LVal")))
        }
      })
    });
    defineType("ArrowFunctionExpression", {
      builder: ["params", "body", "async"],
      visitor: ["params", "body", "returnType", "typeParameters"],
      aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
      fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
        expression: {
          validate: (0, _utils.assertValueType)("boolean")
        },
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
        },
        predicate: {
          validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
          optional: true
        }
      })
    });
    defineType("ClassBody", {
      visitor: ["body"],
      fields: {
        body: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
        }
      }
    });
    defineType("ClassExpression", {
      builder: ["id", "superClass", "body", "decorators"],
      visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
      aliases: ["Scopable", "Class", "Expression"],
      fields: {
        id: {
          validate: (0, _utils.assertNodeType)("Identifier"),
          optional: true
        },
        typeParameters: {
          validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
          optional: true
        },
        body: {
          validate: (0, _utils.assertNodeType)("ClassBody")
        },
        superClass: {
          optional: true,
          validate: (0, _utils.assertNodeType)("Expression")
        },
        superTypeParameters: {
          validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
          optional: true
        },
        implements: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
          optional: true
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        },
        mixins: {
          validate: (0, _utils.assertNodeType)("InterfaceExtends"),
          optional: true
        }
      }
    });
    defineType("ClassDeclaration", {
      inherits: "ClassExpression",
      aliases: ["Scopable", "Class", "Statement", "Declaration"],
      fields: {
        id: {
          validate: (0, _utils.assertNodeType)("Identifier")
        },
        typeParameters: {
          validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
          optional: true
        },
        body: {
          validate: (0, _utils.assertNodeType)("ClassBody")
        },
        superClass: {
          optional: true,
          validate: (0, _utils.assertNodeType)("Expression")
        },
        superTypeParameters: {
          validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
          optional: true
        },
        implements: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
          optional: true
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        },
        mixins: {
          validate: (0, _utils.assertNodeType)("InterfaceExtends"),
          optional: true
        },
        declare: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        abstract: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        }
      },
      validate: function() {
        const identifier = (0, _utils.assertNodeType)("Identifier");
        return function(parent, key2, node2) {
          if (!process.env.BABEL_TYPES_8_BREAKING)
            return;
          if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
            identifier(node2, "id", node2.id);
          }
        };
      }()
    });
    defineType("ExportAllDeclaration", {
      visitor: ["source"],
      aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
      fields: {
        source: {
          validate: (0, _utils.assertNodeType)("StringLiteral")
        },
        exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
        assertions: {
          optional: true,
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
        }
      }
    });
    defineType("ExportDefaultDeclaration", {
      visitor: ["declaration"],
      aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
      fields: {
        declaration: {
          validate: (0, _utils.assertNodeType)("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression")
        },
        exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value"))
      }
    });
    defineType("ExportNamedDeclaration", {
      visitor: ["declaration", "specifiers", "source"],
      aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
      fields: {
        declaration: {
          optional: true,
          validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (val && node2.specifiers.length) {
              throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
            }
          }, {
            oneOfNodeTypes: ["Declaration"]
          }), function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (val && node2.source) {
              throw new TypeError("Cannot export a declaration from a source");
            }
          })
        },
        assertions: {
          optional: true,
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
        },
        specifiers: {
          default: [],
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function() {
            const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
            const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return sourced;
            return function(node2, key2, val) {
              const validator = node2.source ? sourced : sourceless;
              validator(node2, key2, val);
            };
          }()))
        },
        source: {
          validate: (0, _utils.assertNodeType)("StringLiteral"),
          optional: true
        },
        exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
      }
    });
    defineType("ExportSpecifier", {
      visitor: ["local", "exported"],
      aliases: ["ModuleSpecifier"],
      fields: {
        local: {
          validate: (0, _utils.assertNodeType)("Identifier")
        },
        exported: {
          validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
        },
        exportKind: {
          validate: (0, _utils.assertOneOf)("type", "value"),
          optional: true
        }
      }
    });
    defineType("ForOfStatement", {
      visitor: ["left", "right", "body"],
      builder: ["left", "right", "body", "await"],
      aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
      fields: {
        left: {
          validate: function() {
            if (!process.env.BABEL_TYPES_8_BREAKING) {
              return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
            }
            const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
            const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
            return function(node2, key2, val) {
              if ((0, _is.default)("VariableDeclaration", val)) {
                declaration(node2, key2, val);
              } else {
                lval(node2, key2, val);
              }
            };
          }()
        },
        right: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        body: {
          validate: (0, _utils.assertNodeType)("Statement")
        },
        await: {
          default: false
        }
      }
    });
    defineType("ImportDeclaration", {
      visitor: ["specifiers", "source"],
      aliases: ["Statement", "Declaration", "ImportOrExportDeclaration"],
      fields: {
        assertions: {
          optional: true,
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
        },
        module: {
          optional: true,
          validate: (0, _utils.assertValueType)("boolean")
        },
        specifiers: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
        },
        source: {
          validate: (0, _utils.assertNodeType)("StringLiteral")
        },
        importKind: {
          validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
          optional: true
        }
      }
    });
    defineType("ImportDefaultSpecifier", {
      visitor: ["local"],
      aliases: ["ModuleSpecifier"],
      fields: {
        local: {
          validate: (0, _utils.assertNodeType)("Identifier")
        }
      }
    });
    defineType("ImportNamespaceSpecifier", {
      visitor: ["local"],
      aliases: ["ModuleSpecifier"],
      fields: {
        local: {
          validate: (0, _utils.assertNodeType)("Identifier")
        }
      }
    });
    defineType("ImportSpecifier", {
      visitor: ["local", "imported"],
      aliases: ["ModuleSpecifier"],
      fields: {
        local: {
          validate: (0, _utils.assertNodeType)("Identifier")
        },
        imported: {
          validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
        },
        importKind: {
          validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
          optional: true
        }
      }
    });
    defineType("MetaProperty", {
      visitor: ["meta", "property"],
      aliases: ["Expression"],
      fields: {
        meta: {
          validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            let property;
            switch (val.name) {
              case "function":
                property = "sent";
                break;
              case "new":
                property = "target";
                break;
              case "import":
                property = "meta";
                break;
            }
            if (!(0, _is.default)("Identifier", node2.property, {
              name: property
            })) {
              throw new TypeError("Unrecognised MetaProperty");
            }
          }, {
            oneOfNodeTypes: ["Identifier"]
          }))
        },
        property: {
          validate: (0, _utils.assertNodeType)("Identifier")
        }
      }
    });
    var classMethodOrPropertyCommon = () => ({
      abstract: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      accessibility: {
        validate: (0, _utils.assertOneOf)("public", "private", "protected"),
        optional: true
      },
      static: {
        default: false
      },
      override: {
        default: false
      },
      computed: {
        default: false
      },
      optional: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      key: {
        validate: (0, _utils.chain)(function() {
          const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
          const computed = (0, _utils.assertNodeType)("Expression");
          return function(node2, key2, val) {
            const validator = node2.computed ? computed : normal;
            validator(node2, key2, val);
          };
        }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
      }
    });
    exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
    var classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {
      params: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
      },
      kind: {
        validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
        default: "method"
      },
      access: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      }
    });
    exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
    defineType("ClassMethod", {
      aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
      builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
      visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
      fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        }
      })
    });
    defineType("ObjectPattern", {
      visitor: ["properties", "typeAnnotation", "decorators"],
      builder: ["properties"],
      aliases: ["Pattern", "PatternLike", "LVal"],
      fields: Object.assign({}, patternLikeCommon(), {
        properties: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
        }
      })
    });
    defineType("SpreadElement", {
      visitor: ["argument"],
      aliases: ["UnaryLike"],
      deprecatedAlias: "SpreadProperty",
      fields: {
        argument: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("Super", {
      aliases: ["Expression"]
    });
    defineType("TaggedTemplateExpression", {
      visitor: ["tag", "quasi", "typeParameters"],
      builder: ["tag", "quasi"],
      aliases: ["Expression"],
      fields: {
        tag: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        quasi: {
          validate: (0, _utils.assertNodeType)("TemplateLiteral")
        },
        typeParameters: {
          validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
          optional: true
        }
      }
    });
    defineType("TemplateElement", {
      builder: ["value", "tail"],
      fields: {
        value: {
          validate: (0, _utils.chain)((0, _utils.assertShape)({
            raw: {
              validate: (0, _utils.assertValueType)("string")
            },
            cooked: {
              validate: (0, _utils.assertValueType)("string"),
              optional: true
            }
          }), function templateElementCookedValidator(node2) {
            const raw = node2.value.raw;
            let unterminatedCalled = false;
            const error = () => {
              throw new Error("Internal @babel/types error.");
            };
            const {
              str,
              firstInvalidLoc
            } = (0, _helperStringParser.readStringContents)("template", raw, 0, 0, 0, {
              unterminated() {
                unterminatedCalled = true;
              },
              strictNumericEscape: error,
              invalidEscapeSequence: error,
              numericSeparatorInEscapeSequence: error,
              unexpectedNumericSeparator: error,
              invalidDigit: error,
              invalidCodePoint: error
            });
            if (!unterminatedCalled)
              throw new Error("Invalid raw");
            node2.value.cooked = firstInvalidLoc ? null : str;
          })
        },
        tail: {
          default: false
        }
      }
    });
    defineType("TemplateLiteral", {
      visitor: ["quasis", "expressions"],
      aliases: ["Expression", "Literal"],
      fields: {
        quasis: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
        },
        expressions: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function(node2, key2, val) {
            if (node2.quasis.length !== val.length + 1) {
              throw new TypeError(`Number of ${node2.type} quasis should be exactly one more than the number of expressions.
Expected ${val.length + 1} quasis but got ${node2.quasis.length}`);
            }
          })
        }
      }
    });
    defineType("YieldExpression", {
      builder: ["argument", "delegate"],
      visitor: ["argument"],
      aliases: ["Expression", "Terminatorless"],
      fields: {
        delegate: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function(node2, key2, val) {
            if (!process.env.BABEL_TYPES_8_BREAKING)
              return;
            if (val && !node2.argument) {
              throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
            }
          }, {
            type: "boolean"
          })),
          default: false
        },
        argument: {
          optional: true,
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("AwaitExpression", {
      builder: ["argument"],
      visitor: ["argument"],
      aliases: ["Expression", "Terminatorless"],
      fields: {
        argument: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("Import", {
      aliases: ["Expression"]
    });
    defineType("BigIntLiteral", {
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("string")
        }
      },
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
    defineType("ExportNamespaceSpecifier", {
      visitor: ["exported"],
      aliases: ["ModuleSpecifier"],
      fields: {
        exported: {
          validate: (0, _utils.assertNodeType)("Identifier")
        }
      }
    });
    defineType("OptionalMemberExpression", {
      builder: ["object", "property", "computed", "optional"],
      visitor: ["object", "property"],
      aliases: ["Expression"],
      fields: {
        object: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        property: {
          validate: function() {
            const normal = (0, _utils.assertNodeType)("Identifier");
            const computed = (0, _utils.assertNodeType)("Expression");
            const validator = Object.assign(function(node2, key2, val) {
              const validator2 = node2.computed ? computed : normal;
              validator2(node2, key2, val);
            }, {
              oneOfNodeTypes: ["Expression", "Identifier"]
            });
            return validator;
          }()
        },
        computed: {
          default: false
        },
        optional: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
        }
      }
    });
    defineType("OptionalCallExpression", {
      visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
      builder: ["callee", "arguments", "optional"],
      aliases: ["Expression"],
      fields: {
        callee: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        arguments: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
        },
        optional: {
          validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
        },
        typeArguments: {
          validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
          optional: true
        },
        typeParameters: {
          validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
          optional: true
        }
      }
    });
    defineType("ClassProperty", {
      visitor: ["key", "value", "typeAnnotation", "decorators"],
      builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
      aliases: ["Property"],
      fields: Object.assign({}, classMethodOrPropertyCommon(), {
        value: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        },
        definite: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        typeAnnotation: {
          validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
          optional: true
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        },
        readonly: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        declare: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        variance: {
          validate: (0, _utils.assertNodeType)("Variance"),
          optional: true
        }
      })
    });
    defineType("ClassAccessorProperty", {
      visitor: ["key", "value", "typeAnnotation", "decorators"],
      builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
      aliases: ["Property", "Accessor"],
      fields: Object.assign({}, classMethodOrPropertyCommon(), {
        key: {
          validate: (0, _utils.chain)(function() {
            const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
            const computed = (0, _utils.assertNodeType)("Expression");
            return function(node2, key2, val) {
              const validator = node2.computed ? computed : normal;
              validator(node2, key2, val);
            };
          }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
        },
        value: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        },
        definite: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        typeAnnotation: {
          validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
          optional: true
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        },
        readonly: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        declare: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        variance: {
          validate: (0, _utils.assertNodeType)("Variance"),
          optional: true
        }
      })
    });
    defineType("ClassPrivateProperty", {
      visitor: ["key", "value", "decorators", "typeAnnotation"],
      builder: ["key", "value", "decorators", "static"],
      aliases: ["Property", "Private"],
      fields: {
        key: {
          validate: (0, _utils.assertNodeType)("PrivateName")
        },
        value: {
          validate: (0, _utils.assertNodeType)("Expression"),
          optional: true
        },
        typeAnnotation: {
          validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
          optional: true
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        },
        static: {
          validate: (0, _utils.assertValueType)("boolean"),
          default: false
        },
        readonly: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        definite: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        variance: {
          validate: (0, _utils.assertNodeType)("Variance"),
          optional: true
        }
      }
    });
    defineType("ClassPrivateMethod", {
      builder: ["kind", "key", "params", "body", "static"],
      visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
      aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
      fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
        kind: {
          validate: (0, _utils.assertOneOf)("get", "set", "method"),
          default: "method"
        },
        key: {
          validate: (0, _utils.assertNodeType)("PrivateName")
        },
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        }
      })
    });
    defineType("PrivateName", {
      visitor: ["id"],
      aliases: ["Private"],
      fields: {
        id: {
          validate: (0, _utils.assertNodeType)("Identifier")
        }
      }
    });
    defineType("StaticBlock", {
      visitor: ["body"],
      fields: {
        body: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
        }
      },
      aliases: ["Scopable", "BlockParent", "FunctionParent"]
    });
  }
});

// node_modules/@babel/types/lib/definitions/flow.js
var require_flow = __commonJS({
  "node_modules/@babel/types/lib/definitions/flow.js"() {
    "use strict";
    var _utils = require_utils();
    var defineType = (0, _utils.defineAliasedType)("Flow");
    var defineInterfaceishType = (name2) => {
      defineType(name2, {
        builder: ["id", "typeParameters", "extends", "body"],
        visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
        aliases: ["FlowDeclaration", "Statement", "Declaration"],
        fields: {
          id: (0, _utils.validateType)("Identifier"),
          typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
          extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
          mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
          implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
          body: (0, _utils.validateType)("ObjectTypeAnnotation")
        }
      });
    };
    defineType("AnyTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("ArrayTypeAnnotation", {
      visitor: ["elementType"],
      aliases: ["FlowType"],
      fields: {
        elementType: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("BooleanTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("BooleanLiteralTypeAnnotation", {
      builder: ["value"],
      aliases: ["FlowType"],
      fields: {
        value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("NullLiteralTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("ClassImplements", {
      visitor: ["id", "typeParameters"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
      }
    });
    defineInterfaceishType("DeclareClass");
    defineType("DeclareFunction", {
      visitor: ["id"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
      }
    });
    defineInterfaceishType("DeclareInterface");
    defineType("DeclareModule", {
      builder: ["id", "body", "kind"],
      visitor: ["id", "body"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
        body: (0, _utils.validateType)("BlockStatement"),
        kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
      }
    });
    defineType("DeclareModuleExports", {
      visitor: ["typeAnnotation"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
      }
    });
    defineType("DeclareTypeAlias", {
      visitor: ["id", "typeParameters", "right"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
        right: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("DeclareOpaqueType", {
      visitor: ["id", "typeParameters", "supertype"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
        supertype: (0, _utils.validateOptionalType)("FlowType"),
        impltype: (0, _utils.validateOptionalType)("FlowType")
      }
    });
    defineType("DeclareVariable", {
      visitor: ["id"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier")
      }
    });
    defineType("DeclareExportDeclaration", {
      visitor: ["declaration", "specifiers", "source"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        declaration: (0, _utils.validateOptionalType)("Flow"),
        specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
        source: (0, _utils.validateOptionalType)("StringLiteral"),
        default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("DeclareExportAllDeclaration", {
      visitor: ["source"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        source: (0, _utils.validateType)("StringLiteral"),
        exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
      }
    });
    defineType("DeclaredPredicate", {
      visitor: ["value"],
      aliases: ["FlowPredicate"],
      fields: {
        value: (0, _utils.validateType)("Flow")
      }
    });
    defineType("ExistsTypeAnnotation", {
      aliases: ["FlowType"]
    });
    defineType("FunctionTypeAnnotation", {
      visitor: ["typeParameters", "params", "rest", "returnType"],
      aliases: ["FlowType"],
      fields: {
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
        params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
        rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
        this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
        returnType: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("FunctionTypeParam", {
      visitor: ["name", "typeAnnotation"],
      fields: {
        name: (0, _utils.validateOptionalType)("Identifier"),
        typeAnnotation: (0, _utils.validateType)("FlowType"),
        optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("GenericTypeAnnotation", {
      visitor: ["id", "typeParameters"],
      aliases: ["FlowType"],
      fields: {
        id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
      }
    });
    defineType("InferredPredicate", {
      aliases: ["FlowPredicate"]
    });
    defineType("InterfaceExtends", {
      visitor: ["id", "typeParameters"],
      fields: {
        id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
      }
    });
    defineInterfaceishType("InterfaceDeclaration");
    defineType("InterfaceTypeAnnotation", {
      visitor: ["extends", "body"],
      aliases: ["FlowType"],
      fields: {
        extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
        body: (0, _utils.validateType)("ObjectTypeAnnotation")
      }
    });
    defineType("IntersectionTypeAnnotation", {
      visitor: ["types"],
      aliases: ["FlowType"],
      fields: {
        types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
      }
    });
    defineType("MixedTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("EmptyTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("NullableTypeAnnotation", {
      visitor: ["typeAnnotation"],
      aliases: ["FlowType"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("NumberLiteralTypeAnnotation", {
      builder: ["value"],
      aliases: ["FlowType"],
      fields: {
        value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
      }
    });
    defineType("NumberTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("ObjectTypeAnnotation", {
      visitor: ["properties", "indexers", "callProperties", "internalSlots"],
      aliases: ["FlowType"],
      builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
      fields: {
        properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
        indexers: {
          validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"),
          optional: true,
          default: []
        },
        callProperties: {
          validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"),
          optional: true,
          default: []
        },
        internalSlots: {
          validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"),
          optional: true,
          default: []
        },
        exact: {
          validate: (0, _utils.assertValueType)("boolean"),
          default: false
        },
        inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("ObjectTypeInternalSlot", {
      visitor: ["id", "value", "optional", "static", "method"],
      aliases: ["UserWhitespacable"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        value: (0, _utils.validateType)("FlowType"),
        optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("ObjectTypeCallProperty", {
      visitor: ["value"],
      aliases: ["UserWhitespacable"],
      fields: {
        value: (0, _utils.validateType)("FlowType"),
        static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("ObjectTypeIndexer", {
      visitor: ["id", "key", "value", "variance"],
      aliases: ["UserWhitespacable"],
      fields: {
        id: (0, _utils.validateOptionalType)("Identifier"),
        key: (0, _utils.validateType)("FlowType"),
        value: (0, _utils.validateType)("FlowType"),
        static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        variance: (0, _utils.validateOptionalType)("Variance")
      }
    });
    defineType("ObjectTypeProperty", {
      visitor: ["key", "value", "variance"],
      aliases: ["UserWhitespacable"],
      fields: {
        key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
        value: (0, _utils.validateType)("FlowType"),
        kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
        static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        variance: (0, _utils.validateOptionalType)("Variance"),
        method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("ObjectTypeSpreadProperty", {
      visitor: ["argument"],
      aliases: ["UserWhitespacable"],
      fields: {
        argument: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("OpaqueType", {
      visitor: ["id", "typeParameters", "supertype", "impltype"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
        supertype: (0, _utils.validateOptionalType)("FlowType"),
        impltype: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("QualifiedTypeIdentifier", {
      visitor: ["id", "qualification"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
      }
    });
    defineType("StringLiteralTypeAnnotation", {
      builder: ["value"],
      aliases: ["FlowType"],
      fields: {
        value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
      }
    });
    defineType("StringTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("SymbolTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("ThisTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("TupleTypeAnnotation", {
      visitor: ["types"],
      aliases: ["FlowType"],
      fields: {
        types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
      }
    });
    defineType("TypeofTypeAnnotation", {
      visitor: ["argument"],
      aliases: ["FlowType"],
      fields: {
        argument: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("TypeAlias", {
      visitor: ["id", "typeParameters", "right"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
        right: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("TypeAnnotation", {
      visitor: ["typeAnnotation"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("TypeCastExpression", {
      visitor: ["expression", "typeAnnotation"],
      aliases: ["ExpressionWrapper", "Expression"],
      fields: {
        expression: (0, _utils.validateType)("Expression"),
        typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
      }
    });
    defineType("TypeParameter", {
      visitor: ["bound", "default", "variance"],
      fields: {
        name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
        bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
        default: (0, _utils.validateOptionalType)("FlowType"),
        variance: (0, _utils.validateOptionalType)("Variance")
      }
    });
    defineType("TypeParameterDeclaration", {
      visitor: ["params"],
      fields: {
        params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
      }
    });
    defineType("TypeParameterInstantiation", {
      visitor: ["params"],
      fields: {
        params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
      }
    });
    defineType("UnionTypeAnnotation", {
      visitor: ["types"],
      aliases: ["FlowType"],
      fields: {
        types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
      }
    });
    defineType("Variance", {
      builder: ["kind"],
      fields: {
        kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
      }
    });
    defineType("VoidTypeAnnotation", {
      aliases: ["FlowType", "FlowBaseAnnotation"]
    });
    defineType("EnumDeclaration", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "body"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
      }
    });
    defineType("EnumBooleanBody", {
      aliases: ["EnumBody"],
      visitor: ["members"],
      fields: {
        explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
        hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("EnumNumberBody", {
      aliases: ["EnumBody"],
      visitor: ["members"],
      fields: {
        explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
        hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("EnumStringBody", {
      aliases: ["EnumBody"],
      visitor: ["members"],
      fields: {
        explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
        members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
        hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("EnumSymbolBody", {
      aliases: ["EnumBody"],
      visitor: ["members"],
      fields: {
        members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
        hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
    defineType("EnumBooleanMember", {
      aliases: ["EnumMember"],
      visitor: ["id"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        init: (0, _utils.validateType)("BooleanLiteral")
      }
    });
    defineType("EnumNumberMember", {
      aliases: ["EnumMember"],
      visitor: ["id", "init"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        init: (0, _utils.validateType)("NumericLiteral")
      }
    });
    defineType("EnumStringMember", {
      aliases: ["EnumMember"],
      visitor: ["id", "init"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        init: (0, _utils.validateType)("StringLiteral")
      }
    });
    defineType("EnumDefaultedMember", {
      aliases: ["EnumMember"],
      visitor: ["id"],
      fields: {
        id: (0, _utils.validateType)("Identifier")
      }
    });
    defineType("IndexedAccessType", {
      visitor: ["objectType", "indexType"],
      aliases: ["FlowType"],
      fields: {
        objectType: (0, _utils.validateType)("FlowType"),
        indexType: (0, _utils.validateType)("FlowType")
      }
    });
    defineType("OptionalIndexedAccessType", {
      visitor: ["objectType", "indexType"],
      aliases: ["FlowType"],
      fields: {
        objectType: (0, _utils.validateType)("FlowType"),
        indexType: (0, _utils.validateType)("FlowType"),
        optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
      }
    });
  }
});

// node_modules/@babel/types/lib/definitions/jsx.js
var require_jsx = __commonJS({
  "node_modules/@babel/types/lib/definitions/jsx.js"() {
    "use strict";
    var _utils = require_utils();
    var defineType = (0, _utils.defineAliasedType)("JSX");
    defineType("JSXAttribute", {
      visitor: ["name", "value"],
      aliases: ["Immutable"],
      fields: {
        name: {
          validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
        },
        value: {
          optional: true,
          validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
        }
      }
    });
    defineType("JSXClosingElement", {
      visitor: ["name"],
      aliases: ["Immutable"],
      fields: {
        name: {
          validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
        }
      }
    });
    defineType("JSXElement", {
      builder: ["openingElement", "closingElement", "children", "selfClosing"],
      visitor: ["openingElement", "children", "closingElement"],
      aliases: ["Immutable", "Expression"],
      fields: Object.assign({
        openingElement: {
          validate: (0, _utils.assertNodeType)("JSXOpeningElement")
        },
        closingElement: {
          optional: true,
          validate: (0, _utils.assertNodeType)("JSXClosingElement")
        },
        children: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
        }
      }, {
        selfClosing: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        }
      })
    });
    defineType("JSXEmptyExpression", {});
    defineType("JSXExpressionContainer", {
      visitor: ["expression"],
      aliases: ["Immutable"],
      fields: {
        expression: {
          validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
        }
      }
    });
    defineType("JSXSpreadChild", {
      visitor: ["expression"],
      aliases: ["Immutable"],
      fields: {
        expression: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("JSXIdentifier", {
      builder: ["name"],
      fields: {
        name: {
          validate: (0, _utils.assertValueType)("string")
        }
      }
    });
    defineType("JSXMemberExpression", {
      visitor: ["object", "property"],
      fields: {
        object: {
          validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
        },
        property: {
          validate: (0, _utils.assertNodeType)("JSXIdentifier")
        }
      }
    });
    defineType("JSXNamespacedName", {
      visitor: ["namespace", "name"],
      fields: {
        namespace: {
          validate: (0, _utils.assertNodeType)("JSXIdentifier")
        },
        name: {
          validate: (0, _utils.assertNodeType)("JSXIdentifier")
        }
      }
    });
    defineType("JSXOpeningElement", {
      builder: ["name", "attributes", "selfClosing"],
      visitor: ["name", "attributes"],
      aliases: ["Immutable"],
      fields: {
        name: {
          validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
        },
        selfClosing: {
          default: false
        },
        attributes: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
        },
        typeParameters: {
          validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
          optional: true
        }
      }
    });
    defineType("JSXSpreadAttribute", {
      visitor: ["argument"],
      fields: {
        argument: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    defineType("JSXText", {
      aliases: ["Immutable"],
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("string")
        }
      }
    });
    defineType("JSXFragment", {
      builder: ["openingFragment", "closingFragment", "children"],
      visitor: ["openingFragment", "children", "closingFragment"],
      aliases: ["Immutable", "Expression"],
      fields: {
        openingFragment: {
          validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
        },
        closingFragment: {
          validate: (0, _utils.assertNodeType)("JSXClosingFragment")
        },
        children: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
        }
      }
    });
    defineType("JSXOpeningFragment", {
      aliases: ["Immutable"]
    });
    defineType("JSXClosingFragment", {
      aliases: ["Immutable"]
    });
  }
});

// node_modules/@babel/types/lib/definitions/placeholders.js
var require_placeholders = __commonJS({
  "node_modules/@babel/types/lib/definitions/placeholders.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
    var _utils = require_utils();
    var PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
    exports.PLACEHOLDERS = PLACEHOLDERS;
    var PLACEHOLDERS_ALIAS = {
      Declaration: ["Statement"],
      Pattern: ["PatternLike", "LVal"]
    };
    exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
    for (const type of PLACEHOLDERS) {
      const alias = _utils.ALIAS_KEYS[type];
      if (alias != null && alias.length)
        PLACEHOLDERS_ALIAS[type] = alias;
    }
    var PLACEHOLDERS_FLIPPED_ALIAS = {};
    exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
    Object.keys(PLACEHOLDERS_ALIAS).forEach((type) => {
      PLACEHOLDERS_ALIAS[type].forEach((alias) => {
        if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
          PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
        }
        PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);
      });
    });
  }
});

// node_modules/@babel/types/lib/definitions/misc.js
var require_misc = __commonJS({
  "node_modules/@babel/types/lib/definitions/misc.js"() {
    "use strict";
    var _utils = require_utils();
    var _placeholders = require_placeholders();
    var defineType = (0, _utils.defineAliasedType)("Miscellaneous");
    {
      defineType("Noop", {
        visitor: []
      });
    }
    defineType("Placeholder", {
      visitor: [],
      builder: ["expectedNode", "name"],
      fields: {
        name: {
          validate: (0, _utils.assertNodeType)("Identifier")
        },
        expectedNode: {
          validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
        }
      }
    });
    defineType("V8IntrinsicIdentifier", {
      builder: ["name"],
      fields: {
        name: {
          validate: (0, _utils.assertValueType)("string")
        }
      }
    });
  }
});

// node_modules/@babel/types/lib/definitions/experimental.js
var require_experimental = __commonJS({
  "node_modules/@babel/types/lib/definitions/experimental.js"() {
    "use strict";
    var _utils = require_utils();
    (0, _utils.default)("ArgumentPlaceholder", {});
    (0, _utils.default)("BindExpression", {
      visitor: ["object", "callee"],
      aliases: ["Expression"],
      fields: !process.env.BABEL_TYPES_8_BREAKING ? {
        object: {
          validate: Object.assign(() => {
          }, {
            oneOfNodeTypes: ["Expression"]
          })
        },
        callee: {
          validate: Object.assign(() => {
          }, {
            oneOfNodeTypes: ["Expression"]
          })
        }
      } : {
        object: {
          validate: (0, _utils.assertNodeType)("Expression")
        },
        callee: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    (0, _utils.default)("ImportAttribute", {
      visitor: ["key", "value"],
      fields: {
        key: {
          validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
        },
        value: {
          validate: (0, _utils.assertNodeType)("StringLiteral")
        }
      }
    });
    (0, _utils.default)("Decorator", {
      visitor: ["expression"],
      fields: {
        expression: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      }
    });
    (0, _utils.default)("DoExpression", {
      visitor: ["body"],
      builder: ["body", "async"],
      aliases: ["Expression"],
      fields: {
        body: {
          validate: (0, _utils.assertNodeType)("BlockStatement")
        },
        async: {
          validate: (0, _utils.assertValueType)("boolean"),
          default: false
        }
      }
    });
    (0, _utils.default)("ExportDefaultSpecifier", {
      visitor: ["exported"],
      aliases: ["ModuleSpecifier"],
      fields: {
        exported: {
          validate: (0, _utils.assertNodeType)("Identifier")
        }
      }
    });
    (0, _utils.default)("RecordExpression", {
      visitor: ["properties"],
      aliases: ["Expression"],
      fields: {
        properties: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
        }
      }
    });
    (0, _utils.default)("TupleExpression", {
      fields: {
        elements: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
          default: []
        }
      },
      visitor: ["elements"],
      aliases: ["Expression"]
    });
    (0, _utils.default)("DecimalLiteral", {
      builder: ["value"],
      fields: {
        value: {
          validate: (0, _utils.assertValueType)("string")
        }
      },
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
    (0, _utils.default)("ModuleExpression", {
      visitor: ["body"],
      fields: {
        body: {
          validate: (0, _utils.assertNodeType)("Program")
        }
      },
      aliases: ["Expression"]
    });
    (0, _utils.default)("TopicReference", {
      aliases: ["Expression"]
    });
    (0, _utils.default)("PipelineTopicExpression", {
      builder: ["expression"],
      visitor: ["expression"],
      fields: {
        expression: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      },
      aliases: ["Expression"]
    });
    (0, _utils.default)("PipelineBareFunction", {
      builder: ["callee"],
      visitor: ["callee"],
      fields: {
        callee: {
          validate: (0, _utils.assertNodeType)("Expression")
        }
      },
      aliases: ["Expression"]
    });
    (0, _utils.default)("PipelinePrimaryTopicReference", {
      aliases: ["Expression"]
    });
  }
});

// node_modules/@babel/types/lib/definitions/typescript.js
var require_typescript = __commonJS({
  "node_modules/@babel/types/lib/definitions/typescript.js"() {
    "use strict";
    var _utils = require_utils();
    var _core = require_core();
    var _is = require_is();
    var defineType = (0, _utils.defineAliasedType)("TypeScript");
    var bool = (0, _utils.assertValueType)("boolean");
    var tSFunctionTypeAnnotationCommon = () => ({
      returnType: {
        validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
        optional: true
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
        optional: true
      }
    });
    defineType("TSParameterProperty", {
      aliases: ["LVal"],
      visitor: ["parameter"],
      fields: {
        accessibility: {
          validate: (0, _utils.assertOneOf)("public", "private", "protected"),
          optional: true
        },
        readonly: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        parameter: {
          validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
        },
        override: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        decorators: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
          optional: true
        }
      }
    });
    defineType("TSDeclareFunction", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "typeParameters", "params", "returnType"],
      fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())
    });
    defineType("TSDeclareMethod", {
      visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
      fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())
    });
    defineType("TSQualifiedName", {
      aliases: ["TSEntityName"],
      visitor: ["left", "right"],
      fields: {
        left: (0, _utils.validateType)("TSEntityName"),
        right: (0, _utils.validateType)("Identifier")
      }
    });
    var signatureDeclarationCommon = () => ({
      typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
      ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
      ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
    });
    var callConstructSignatureDeclaration = {
      aliases: ["TSTypeElement"],
      visitor: ["typeParameters", "parameters", "typeAnnotation"],
      fields: signatureDeclarationCommon()
    };
    defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
    defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
    var namedTypeElementCommon = () => ({
      key: (0, _utils.validateType)("Expression"),
      computed: {
        default: false
      },
      optional: (0, _utils.validateOptional)(bool)
    });
    defineType("TSPropertySignature", {
      aliases: ["TSTypeElement"],
      visitor: ["key", "typeAnnotation", "initializer"],
      fields: Object.assign({}, namedTypeElementCommon(), {
        readonly: (0, _utils.validateOptional)(bool),
        typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
        initializer: (0, _utils.validateOptionalType)("Expression"),
        kind: {
          validate: (0, _utils.assertOneOf)("get", "set")
        }
      })
    });
    defineType("TSMethodSignature", {
      aliases: ["TSTypeElement"],
      visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
      fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {
        kind: {
          validate: (0, _utils.assertOneOf)("method", "get", "set")
        }
      })
    });
    defineType("TSIndexSignature", {
      aliases: ["TSTypeElement"],
      visitor: ["parameters", "typeAnnotation"],
      fields: {
        readonly: (0, _utils.validateOptional)(bool),
        static: (0, _utils.validateOptional)(bool),
        parameters: (0, _utils.validateArrayOfType)("Identifier"),
        typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
      }
    });
    var tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
    for (const type of tsKeywordTypes) {
      defineType(type, {
        aliases: ["TSType", "TSBaseType"],
        visitor: [],
        fields: {}
      });
    }
    defineType("TSThisType", {
      aliases: ["TSType", "TSBaseType"],
      visitor: [],
      fields: {}
    });
    var fnOrCtrBase = {
      aliases: ["TSType"],
      visitor: ["typeParameters", "parameters", "typeAnnotation"]
    };
    defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
      fields: signatureDeclarationCommon()
    }));
    defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
      fields: Object.assign({}, signatureDeclarationCommon(), {
        abstract: (0, _utils.validateOptional)(bool)
      })
    }));
    defineType("TSTypeReference", {
      aliases: ["TSType"],
      visitor: ["typeName", "typeParameters"],
      fields: {
        typeName: (0, _utils.validateType)("TSEntityName"),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
      }
    });
    defineType("TSTypePredicate", {
      aliases: ["TSType"],
      visitor: ["parameterName", "typeAnnotation"],
      builder: ["parameterName", "typeAnnotation", "asserts"],
      fields: {
        parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
        typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
        asserts: (0, _utils.validateOptional)(bool)
      }
    });
    defineType("TSTypeQuery", {
      aliases: ["TSType"],
      visitor: ["exprName", "typeParameters"],
      fields: {
        exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
      }
    });
    defineType("TSTypeLiteral", {
      aliases: ["TSType"],
      visitor: ["members"],
      fields: {
        members: (0, _utils.validateArrayOfType)("TSTypeElement")
      }
    });
    defineType("TSArrayType", {
      aliases: ["TSType"],
      visitor: ["elementType"],
      fields: {
        elementType: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSTupleType", {
      aliases: ["TSType"],
      visitor: ["elementTypes"],
      fields: {
        elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
      }
    });
    defineType("TSOptionalType", {
      aliases: ["TSType"],
      visitor: ["typeAnnotation"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSRestType", {
      aliases: ["TSType"],
      visitor: ["typeAnnotation"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSNamedTupleMember", {
      visitor: ["label", "elementType"],
      builder: ["label", "elementType", "optional"],
      fields: {
        label: (0, _utils.validateType)("Identifier"),
        optional: {
          validate: bool,
          default: false
        },
        elementType: (0, _utils.validateType)("TSType")
      }
    });
    var unionOrIntersection = {
      aliases: ["TSType"],
      visitor: ["types"],
      fields: {
        types: (0, _utils.validateArrayOfType)("TSType")
      }
    };
    defineType("TSUnionType", unionOrIntersection);
    defineType("TSIntersectionType", unionOrIntersection);
    defineType("TSConditionalType", {
      aliases: ["TSType"],
      visitor: ["checkType", "extendsType", "trueType", "falseType"],
      fields: {
        checkType: (0, _utils.validateType)("TSType"),
        extendsType: (0, _utils.validateType)("TSType"),
        trueType: (0, _utils.validateType)("TSType"),
        falseType: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSInferType", {
      aliases: ["TSType"],
      visitor: ["typeParameter"],
      fields: {
        typeParameter: (0, _utils.validateType)("TSTypeParameter")
      }
    });
    defineType("TSParenthesizedType", {
      aliases: ["TSType"],
      visitor: ["typeAnnotation"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSTypeOperator", {
      aliases: ["TSType"],
      visitor: ["typeAnnotation"],
      fields: {
        operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
        typeAnnotation: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSIndexedAccessType", {
      aliases: ["TSType"],
      visitor: ["objectType", "indexType"],
      fields: {
        objectType: (0, _utils.validateType)("TSType"),
        indexType: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSMappedType", {
      aliases: ["TSType"],
      visitor: ["typeParameter", "typeAnnotation", "nameType"],
      fields: {
        readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
        typeParameter: (0, _utils.validateType)("TSTypeParameter"),
        optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
        typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
        nameType: (0, _utils.validateOptionalType)("TSType")
      }
    });
    defineType("TSLiteralType", {
      aliases: ["TSType", "TSBaseType"],
      visitor: ["literal"],
      fields: {
        literal: {
          validate: function() {
            const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
            const unaryOperator = (0, _utils.assertOneOf)("-");
            const literal4 = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
            function validator(parent, key2, node2) {
              if ((0, _is.default)("UnaryExpression", node2)) {
                unaryOperator(node2, "operator", node2.operator);
                unaryExpression(node2, "argument", node2.argument);
              } else {
                literal4(parent, key2, node2);
              }
            }
            validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"];
            return validator;
          }()
        }
      }
    });
    defineType("TSExpressionWithTypeArguments", {
      aliases: ["TSType"],
      visitor: ["expression", "typeParameters"],
      fields: {
        expression: (0, _utils.validateType)("TSEntityName"),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
      }
    });
    defineType("TSInterfaceDeclaration", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "typeParameters", "extends", "body"],
      fields: {
        declare: (0, _utils.validateOptional)(bool),
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
        extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
        body: (0, _utils.validateType)("TSInterfaceBody")
      }
    });
    defineType("TSInterfaceBody", {
      visitor: ["body"],
      fields: {
        body: (0, _utils.validateArrayOfType)("TSTypeElement")
      }
    });
    defineType("TSTypeAliasDeclaration", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "typeParameters", "typeAnnotation"],
      fields: {
        declare: (0, _utils.validateOptional)(bool),
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
        typeAnnotation: (0, _utils.validateType)("TSType")
      }
    });
    defineType("TSInstantiationExpression", {
      aliases: ["Expression"],
      visitor: ["expression", "typeParameters"],
      fields: {
        expression: (0, _utils.validateType)("Expression"),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
      }
    });
    var TSTypeExpression = {
      aliases: ["Expression", "LVal", "PatternLike"],
      visitor: ["expression", "typeAnnotation"],
      fields: {
        expression: (0, _utils.validateType)("Expression"),
        typeAnnotation: (0, _utils.validateType)("TSType")
      }
    };
    defineType("TSAsExpression", TSTypeExpression);
    defineType("TSSatisfiesExpression", TSTypeExpression);
    defineType("TSTypeAssertion", {
      aliases: ["Expression", "LVal", "PatternLike"],
      visitor: ["typeAnnotation", "expression"],
      fields: {
        typeAnnotation: (0, _utils.validateType)("TSType"),
        expression: (0, _utils.validateType)("Expression")
      }
    });
    defineType("TSEnumDeclaration", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "members"],
      fields: {
        declare: (0, _utils.validateOptional)(bool),
        const: (0, _utils.validateOptional)(bool),
        id: (0, _utils.validateType)("Identifier"),
        members: (0, _utils.validateArrayOfType)("TSEnumMember"),
        initializer: (0, _utils.validateOptionalType)("Expression")
      }
    });
    defineType("TSEnumMember", {
      visitor: ["id", "initializer"],
      fields: {
        id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
        initializer: (0, _utils.validateOptionalType)("Expression")
      }
    });
    defineType("TSModuleDeclaration", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "body"],
      fields: {
        declare: (0, _utils.validateOptional)(bool),
        global: (0, _utils.validateOptional)(bool),
        id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
        body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
      }
    });
    defineType("TSModuleBlock", {
      aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"],
      visitor: ["body"],
      fields: {
        body: (0, _utils.validateArrayOfType)("Statement")
      }
    });
    defineType("TSImportType", {
      aliases: ["TSType"],
      visitor: ["argument", "qualifier", "typeParameters"],
      fields: {
        argument: (0, _utils.validateType)("StringLiteral"),
        qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
        typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
      }
    });
    defineType("TSImportEqualsDeclaration", {
      aliases: ["Statement"],
      visitor: ["id", "moduleReference"],
      fields: {
        isExport: (0, _utils.validate)(bool),
        id: (0, _utils.validateType)("Identifier"),
        moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
        importKind: {
          validate: (0, _utils.assertOneOf)("type", "value"),
          optional: true
        }
      }
    });
    defineType("TSExternalModuleReference", {
      visitor: ["expression"],
      fields: {
        expression: (0, _utils.validateType)("StringLiteral")
      }
    });
    defineType("TSNonNullExpression", {
      aliases: ["Expression", "LVal", "PatternLike"],
      visitor: ["expression"],
      fields: {
        expression: (0, _utils.validateType)("Expression")
      }
    });
    defineType("TSExportAssignment", {
      aliases: ["Statement"],
      visitor: ["expression"],
      fields: {
        expression: (0, _utils.validateType)("Expression")
      }
    });
    defineType("TSNamespaceExportDeclaration", {
      aliases: ["Statement"],
      visitor: ["id"],
      fields: {
        id: (0, _utils.validateType)("Identifier")
      }
    });
    defineType("TSTypeAnnotation", {
      visitor: ["typeAnnotation"],
      fields: {
        typeAnnotation: {
          validate: (0, _utils.assertNodeType)("TSType")
        }
      }
    });
    defineType("TSTypeParameterInstantiation", {
      visitor: ["params"],
      fields: {
        params: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
        }
      }
    });
    defineType("TSTypeParameterDeclaration", {
      visitor: ["params"],
      fields: {
        params: {
          validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
        }
      }
    });
    defineType("TSTypeParameter", {
      builder: ["constraint", "default", "name"],
      visitor: ["constraint", "default"],
      fields: {
        name: {
          validate: (0, _utils.assertValueType)("string")
        },
        in: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        out: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        const: {
          validate: (0, _utils.assertValueType)("boolean"),
          optional: true
        },
        constraint: {
          validate: (0, _utils.assertNodeType)("TSType"),
          optional: true
        },
        default: {
          validate: (0, _utils.assertNodeType)("TSType"),
          optional: true
        }
      }
    });
  }
});

// node_modules/@babel/types/lib/definitions/deprecated-aliases.js
var require_deprecated_aliases = __commonJS({
  "node_modules/@babel/types/lib/definitions/deprecated-aliases.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.DEPRECATED_ALIASES = void 0;
    var DEPRECATED_ALIASES = {
      ModuleDeclaration: "ImportOrExportDeclaration"
    };
    exports.DEPRECATED_ALIASES = DEPRECATED_ALIASES;
  }
});

// node_modules/@babel/types/lib/definitions/index.js
var require_definitions = __commonJS({
  "node_modules/@babel/types/lib/definitions/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "ALIAS_KEYS", {
      enumerable: true,
      get: function() {
        return _utils.ALIAS_KEYS;
      }
    });
    Object.defineProperty(exports, "BUILDER_KEYS", {
      enumerable: true,
      get: function() {
        return _utils.BUILDER_KEYS;
      }
    });
    Object.defineProperty(exports, "DEPRECATED_ALIASES", {
      enumerable: true,
      get: function() {
        return _deprecatedAliases.DEPRECATED_ALIASES;
      }
    });
    Object.defineProperty(exports, "DEPRECATED_KEYS", {
      enumerable: true,
      get: function() {
        return _utils.DEPRECATED_KEYS;
      }
    });
    Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
      enumerable: true,
      get: function() {
        return _utils.FLIPPED_ALIAS_KEYS;
      }
    });
    Object.defineProperty(exports, "NODE_FIELDS", {
      enumerable: true,
      get: function() {
        return _utils.NODE_FIELDS;
      }
    });
    Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
      enumerable: true,
      get: function() {
        return _utils.NODE_PARENT_VALIDATIONS;
      }
    });
    Object.defineProperty(exports, "PLACEHOLDERS", {
      enumerable: true,
      get: function() {
        return _placeholders.PLACEHOLDERS;
      }
    });
    Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
      enumerable: true,
      get: function() {
        return _placeholders.PLACEHOLDERS_ALIAS;
      }
    });
    Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
      enumerable: true,
      get: function() {
        return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
      }
    });
    exports.TYPES = void 0;
    Object.defineProperty(exports, "VISITOR_KEYS", {
      enumerable: true,
      get: function() {
        return _utils.VISITOR_KEYS;
      }
    });
    var _toFastProperties = require_to_fast_properties();
    require_core();
    require_flow();
    require_jsx();
    require_misc();
    require_experimental();
    require_typescript();
    var _utils = require_utils();
    var _placeholders = require_placeholders();
    var _deprecatedAliases = require_deprecated_aliases();
    Object.keys(_deprecatedAliases.DEPRECATED_ALIASES).forEach((deprecatedAlias) => {
      _utils.FLIPPED_ALIAS_KEYS[deprecatedAlias] = _utils.FLIPPED_ALIAS_KEYS[_deprecatedAliases.DEPRECATED_ALIASES[deprecatedAlias]];
    });
    _toFastProperties(_utils.VISITOR_KEYS);
    _toFastProperties(_utils.ALIAS_KEYS);
    _toFastProperties(_utils.FLIPPED_ALIAS_KEYS);
    _toFastProperties(_utils.NODE_FIELDS);
    _toFastProperties(_utils.BUILDER_KEYS);
    _toFastProperties(_utils.DEPRECATED_KEYS);
    _toFastProperties(_placeholders.PLACEHOLDERS_ALIAS);
    _toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
    var TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS));
    exports.TYPES = TYPES;
  }
});

// node_modules/@babel/types/lib/validators/validate.js
var require_validate = __commonJS({
  "node_modules/@babel/types/lib/validators/validate.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = validate;
    exports.validateChild = validateChild;
    exports.validateField = validateField;
    var _definitions = require_definitions();
    function validate(node2, key2, val) {
      if (!node2)
        return;
      const fields = _definitions.NODE_FIELDS[node2.type];
      if (!fields)
        return;
      const field = fields[key2];
      validateField(node2, key2, val, field);
      validateChild(node2, key2, val);
    }
    function validateField(node2, key2, val, field) {
      if (!(field != null && field.validate))
        return;
      if (field.optional && val == null)
        return;
      field.validate(node2, key2, val);
    }
    function validateChild(node2, key2, val) {
      if (val == null)
        return;
      const validate2 = _definitions.NODE_PARENT_VALIDATIONS[val.type];
      if (!validate2)
        return;
      validate2(node2, key2, val);
    }
  }
});

// node_modules/@babel/types/lib/builders/validateNode.js
var require_validateNode = __commonJS({
  "node_modules/@babel/types/lib/builders/validateNode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = validateNode;
    var _validate = require_validate();
    var _ = require_lib3();
    function validateNode(node2) {
      const keys2 = _.BUILDER_KEYS[node2.type];
      for (const key2 of keys2) {
        (0, _validate.default)(node2, key2, node2[key2]);
      }
      return node2;
    }
  }
});

// node_modules/@babel/types/lib/builders/generated/index.js
var require_generated2 = __commonJS({
  "node_modules/@babel/types/lib/builders/generated/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.anyTypeAnnotation = anyTypeAnnotation;
    exports.argumentPlaceholder = argumentPlaceholder;
    exports.arrayExpression = arrayExpression;
    exports.arrayPattern = arrayPattern;
    exports.arrayTypeAnnotation = arrayTypeAnnotation;
    exports.arrowFunctionExpression = arrowFunctionExpression;
    exports.assignmentExpression = assignmentExpression;
    exports.assignmentPattern = assignmentPattern;
    exports.awaitExpression = awaitExpression;
    exports.bigIntLiteral = bigIntLiteral;
    exports.binaryExpression = binaryExpression;
    exports.bindExpression = bindExpression;
    exports.blockStatement = blockStatement;
    exports.booleanLiteral = booleanLiteral;
    exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
    exports.booleanTypeAnnotation = booleanTypeAnnotation;
    exports.breakStatement = breakStatement;
    exports.callExpression = callExpression;
    exports.catchClause = catchClause;
    exports.classAccessorProperty = classAccessorProperty;
    exports.classBody = classBody;
    exports.classDeclaration = classDeclaration;
    exports.classExpression = classExpression;
    exports.classImplements = classImplements;
    exports.classMethod = classMethod;
    exports.classPrivateMethod = classPrivateMethod;
    exports.classPrivateProperty = classPrivateProperty;
    exports.classProperty = classProperty;
    exports.conditionalExpression = conditionalExpression;
    exports.continueStatement = continueStatement;
    exports.debuggerStatement = debuggerStatement;
    exports.decimalLiteral = decimalLiteral;
    exports.declareClass = declareClass;
    exports.declareExportAllDeclaration = declareExportAllDeclaration;
    exports.declareExportDeclaration = declareExportDeclaration;
    exports.declareFunction = declareFunction;
    exports.declareInterface = declareInterface;
    exports.declareModule = declareModule;
    exports.declareModuleExports = declareModuleExports;
    exports.declareOpaqueType = declareOpaqueType;
    exports.declareTypeAlias = declareTypeAlias;
    exports.declareVariable = declareVariable;
    exports.declaredPredicate = declaredPredicate;
    exports.decorator = decorator;
    exports.directive = directive;
    exports.directiveLiteral = directiveLiteral;
    exports.doExpression = doExpression;
    exports.doWhileStatement = doWhileStatement;
    exports.emptyStatement = emptyStatement;
    exports.emptyTypeAnnotation = emptyTypeAnnotation;
    exports.enumBooleanBody = enumBooleanBody;
    exports.enumBooleanMember = enumBooleanMember;
    exports.enumDeclaration = enumDeclaration;
    exports.enumDefaultedMember = enumDefaultedMember;
    exports.enumNumberBody = enumNumberBody;
    exports.enumNumberMember = enumNumberMember;
    exports.enumStringBody = enumStringBody;
    exports.enumStringMember = enumStringMember;
    exports.enumSymbolBody = enumSymbolBody;
    exports.existsTypeAnnotation = existsTypeAnnotation;
    exports.exportAllDeclaration = exportAllDeclaration;
    exports.exportDefaultDeclaration = exportDefaultDeclaration;
    exports.exportDefaultSpecifier = exportDefaultSpecifier;
    exports.exportNamedDeclaration = exportNamedDeclaration;
    exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
    exports.exportSpecifier = exportSpecifier;
    exports.expressionStatement = expressionStatement;
    exports.file = file;
    exports.forInStatement = forInStatement;
    exports.forOfStatement = forOfStatement;
    exports.forStatement = forStatement;
    exports.functionDeclaration = functionDeclaration;
    exports.functionExpression = functionExpression;
    exports.functionTypeAnnotation = functionTypeAnnotation;
    exports.functionTypeParam = functionTypeParam;
    exports.genericTypeAnnotation = genericTypeAnnotation;
    exports.identifier = identifier;
    exports.ifStatement = ifStatement;
    exports.import = _import;
    exports.importAttribute = importAttribute;
    exports.importDeclaration = importDeclaration;
    exports.importDefaultSpecifier = importDefaultSpecifier;
    exports.importNamespaceSpecifier = importNamespaceSpecifier;
    exports.importSpecifier = importSpecifier;
    exports.indexedAccessType = indexedAccessType;
    exports.inferredPredicate = inferredPredicate;
    exports.interfaceDeclaration = interfaceDeclaration;
    exports.interfaceExtends = interfaceExtends;
    exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
    exports.interpreterDirective = interpreterDirective;
    exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
    exports.jSXAttribute = exports.jsxAttribute = jsxAttribute2;
    exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
    exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
    exports.jSXElement = exports.jsxElement = jsxElement;
    exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
    exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
    exports.jSXFragment = exports.jsxFragment = jsxFragment;
    exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier2;
    exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
    exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
    exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
    exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
    exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
    exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
    exports.jSXText = exports.jsxText = jsxText2;
    exports.labeledStatement = labeledStatement;
    exports.logicalExpression = logicalExpression;
    exports.memberExpression = memberExpression;
    exports.metaProperty = metaProperty;
    exports.mixedTypeAnnotation = mixedTypeAnnotation;
    exports.moduleExpression = moduleExpression;
    exports.newExpression = newExpression;
    exports.noop = noop;
    exports.nullLiteral = nullLiteral;
    exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
    exports.nullableTypeAnnotation = nullableTypeAnnotation;
    exports.numberLiteral = NumberLiteral;
    exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
    exports.numberTypeAnnotation = numberTypeAnnotation;
    exports.numericLiteral = numericLiteral;
    exports.objectExpression = objectExpression;
    exports.objectMethod = objectMethod;
    exports.objectPattern = objectPattern;
    exports.objectProperty = objectProperty;
    exports.objectTypeAnnotation = objectTypeAnnotation;
    exports.objectTypeCallProperty = objectTypeCallProperty;
    exports.objectTypeIndexer = objectTypeIndexer;
    exports.objectTypeInternalSlot = objectTypeInternalSlot;
    exports.objectTypeProperty = objectTypeProperty;
    exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
    exports.opaqueType = opaqueType;
    exports.optionalCallExpression = optionalCallExpression;
    exports.optionalIndexedAccessType = optionalIndexedAccessType;
    exports.optionalMemberExpression = optionalMemberExpression;
    exports.parenthesizedExpression = parenthesizedExpression;
    exports.pipelineBareFunction = pipelineBareFunction;
    exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
    exports.pipelineTopicExpression = pipelineTopicExpression;
    exports.placeholder = placeholder;
    exports.privateName = privateName;
    exports.program = program;
    exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
    exports.recordExpression = recordExpression;
    exports.regExpLiteral = regExpLiteral;
    exports.regexLiteral = RegexLiteral;
    exports.restElement = restElement;
    exports.restProperty = RestProperty;
    exports.returnStatement = returnStatement;
    exports.sequenceExpression = sequenceExpression;
    exports.spreadElement = spreadElement;
    exports.spreadProperty = SpreadProperty;
    exports.staticBlock = staticBlock;
    exports.stringLiteral = stringLiteral2;
    exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
    exports.stringTypeAnnotation = stringTypeAnnotation;
    exports.super = _super;
    exports.switchCase = switchCase;
    exports.switchStatement = switchStatement;
    exports.symbolTypeAnnotation = symbolTypeAnnotation;
    exports.taggedTemplateExpression = taggedTemplateExpression;
    exports.templateElement = templateElement;
    exports.templateLiteral = templateLiteral;
    exports.thisExpression = thisExpression;
    exports.thisTypeAnnotation = thisTypeAnnotation;
    exports.throwStatement = throwStatement;
    exports.topicReference = topicReference;
    exports.tryStatement = tryStatement;
    exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
    exports.tSArrayType = exports.tsArrayType = tsArrayType;
    exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
    exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
    exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
    exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
    exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
    exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
    exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
    exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
    exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
    exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
    exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
    exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
    exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
    exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
    exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
    exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
    exports.tSImportType = exports.tsImportType = tsImportType;
    exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
    exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
    exports.tSInferType = exports.tsInferType = tsInferType;
    exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression;
    exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
    exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
    exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
    exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
    exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
    exports.tSMappedType = exports.tsMappedType = tsMappedType;
    exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
    exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
    exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
    exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
    exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
    exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
    exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
    exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
    exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
    exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
    exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
    exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
    exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
    exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
    exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
    exports.tSRestType = exports.tsRestType = tsRestType;
    exports.tSSatisfiesExpression = exports.tsSatisfiesExpression = tsSatisfiesExpression;
    exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
    exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
    exports.tSThisType = exports.tsThisType = tsThisType;
    exports.tSTupleType = exports.tsTupleType = tsTupleType;
    exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
    exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
    exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
    exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
    exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
    exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
    exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
    exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
    exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
    exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
    exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
    exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
    exports.tSUnionType = exports.tsUnionType = tsUnionType;
    exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
    exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
    exports.tupleExpression = tupleExpression;
    exports.tupleTypeAnnotation = tupleTypeAnnotation;
    exports.typeAlias = typeAlias;
    exports.typeAnnotation = typeAnnotation;
    exports.typeCastExpression = typeCastExpression;
    exports.typeParameter = typeParameter;
    exports.typeParameterDeclaration = typeParameterDeclaration;
    exports.typeParameterInstantiation = typeParameterInstantiation;
    exports.typeofTypeAnnotation = typeofTypeAnnotation;
    exports.unaryExpression = unaryExpression;
    exports.unionTypeAnnotation = unionTypeAnnotation;
    exports.updateExpression = updateExpression;
    exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
    exports.variableDeclaration = variableDeclaration;
    exports.variableDeclarator = variableDeclarator;
    exports.variance = variance;
    exports.voidTypeAnnotation = voidTypeAnnotation;
    exports.whileStatement = whileStatement;
    exports.withStatement = withStatement;
    exports.yieldExpression = yieldExpression;
    var _validateNode = require_validateNode();
    var _deprecationWarning = require_deprecationWarning();
    function arrayExpression(elements = []) {
      return (0, _validateNode.default)({
        type: "ArrayExpression",
        elements
      });
    }
    function assignmentExpression(operator, left, right) {
      return (0, _validateNode.default)({
        type: "AssignmentExpression",
        operator,
        left,
        right
      });
    }
    function binaryExpression(operator, left, right) {
      return (0, _validateNode.default)({
        type: "BinaryExpression",
        operator,
        left,
        right
      });
    }
    function interpreterDirective(value2) {
      return (0, _validateNode.default)({
        type: "InterpreterDirective",
        value: value2
      });
    }
    function directive(value2) {
      return (0, _validateNode.default)({
        type: "Directive",
        value: value2
      });
    }
    function directiveLiteral(value2) {
      return (0, _validateNode.default)({
        type: "DirectiveLiteral",
        value: value2
      });
    }
    function blockStatement(body, directives = []) {
      return (0, _validateNode.default)({
        type: "BlockStatement",
        body,
        directives
      });
    }
    function breakStatement(label = null) {
      return (0, _validateNode.default)({
        type: "BreakStatement",
        label
      });
    }
    function callExpression(callee, _arguments) {
      return (0, _validateNode.default)({
        type: "CallExpression",
        callee,
        arguments: _arguments
      });
    }
    function catchClause(param = null, body) {
      return (0, _validateNode.default)({
        type: "CatchClause",
        param,
        body
      });
    }
    function conditionalExpression(test, consequent, alternate) {
      return (0, _validateNode.default)({
        type: "ConditionalExpression",
        test,
        consequent,
        alternate
      });
    }
    function continueStatement(label = null) {
      return (0, _validateNode.default)({
        type: "ContinueStatement",
        label
      });
    }
    function debuggerStatement() {
      return {
        type: "DebuggerStatement"
      };
    }
    function doWhileStatement(test, body) {
      return (0, _validateNode.default)({
        type: "DoWhileStatement",
        test,
        body
      });
    }
    function emptyStatement() {
      return {
        type: "EmptyStatement"
      };
    }
    function expressionStatement(expression) {
      return (0, _validateNode.default)({
        type: "ExpressionStatement",
        expression
      });
    }
    function file(program2, comments = null, tokens = null) {
      return (0, _validateNode.default)({
        type: "File",
        program: program2,
        comments,
        tokens
      });
    }
    function forInStatement(left, right, body) {
      return (0, _validateNode.default)({
        type: "ForInStatement",
        left,
        right,
        body
      });
    }
    function forStatement(init = null, test = null, update = null, body) {
      return (0, _validateNode.default)({
        type: "ForStatement",
        init,
        test,
        update,
        body
      });
    }
    function functionDeclaration(id = null, params, body, generator = false, async = false) {
      return (0, _validateNode.default)({
        type: "FunctionDeclaration",
        id,
        params,
        body,
        generator,
        async
      });
    }
    function functionExpression(id = null, params, body, generator = false, async = false) {
      return (0, _validateNode.default)({
        type: "FunctionExpression",
        id,
        params,
        body,
        generator,
        async
      });
    }
    function identifier(name2) {
      return (0, _validateNode.default)({
        type: "Identifier",
        name: name2
      });
    }
    function ifStatement(test, consequent, alternate = null) {
      return (0, _validateNode.default)({
        type: "IfStatement",
        test,
        consequent,
        alternate
      });
    }
    function labeledStatement(label, body) {
      return (0, _validateNode.default)({
        type: "LabeledStatement",
        label,
        body
      });
    }
    function stringLiteral2(value2) {
      return (0, _validateNode.default)({
        type: "StringLiteral",
        value: value2
      });
    }
    function numericLiteral(value2) {
      return (0, _validateNode.default)({
        type: "NumericLiteral",
        value: value2
      });
    }
    function nullLiteral() {
      return {
        type: "NullLiteral"
      };
    }
    function booleanLiteral(value2) {
      return (0, _validateNode.default)({
        type: "BooleanLiteral",
        value: value2
      });
    }
    function regExpLiteral(pattern, flags = "") {
      return (0, _validateNode.default)({
        type: "RegExpLiteral",
        pattern,
        flags
      });
    }
    function logicalExpression(operator, left, right) {
      return (0, _validateNode.default)({
        type: "LogicalExpression",
        operator,
        left,
        right
      });
    }
    function memberExpression(object, property, computed = false, optional = null) {
      return (0, _validateNode.default)({
        type: "MemberExpression",
        object,
        property,
        computed,
        optional
      });
    }
    function newExpression(callee, _arguments) {
      return (0, _validateNode.default)({
        type: "NewExpression",
        callee,
        arguments: _arguments
      });
    }
    function program(body, directives = [], sourceType = "script", interpreter = null) {
      return (0, _validateNode.default)({
        type: "Program",
        body,
        directives,
        sourceType,
        interpreter,
        sourceFile: null
      });
    }
    function objectExpression(properties) {
      return (0, _validateNode.default)({
        type: "ObjectExpression",
        properties
      });
    }
    function objectMethod(kind = "method", key2, params, body, computed = false, generator = false, async = false) {
      return (0, _validateNode.default)({
        type: "ObjectMethod",
        kind,
        key: key2,
        params,
        body,
        computed,
        generator,
        async
      });
    }
    function objectProperty(key2, value2, computed = false, shorthand = false, decorators = null) {
      return (0, _validateNode.default)({
        type: "ObjectProperty",
        key: key2,
        value: value2,
        computed,
        shorthand,
        decorators
      });
    }
    function restElement(argument) {
      return (0, _validateNode.default)({
        type: "RestElement",
        argument
      });
    }
    function returnStatement(argument = null) {
      return (0, _validateNode.default)({
        type: "ReturnStatement",
        argument
      });
    }
    function sequenceExpression(expressions) {
      return (0, _validateNode.default)({
        type: "SequenceExpression",
        expressions
      });
    }
    function parenthesizedExpression(expression) {
      return (0, _validateNode.default)({
        type: "ParenthesizedExpression",
        expression
      });
    }
    function switchCase(test = null, consequent) {
      return (0, _validateNode.default)({
        type: "SwitchCase",
        test,
        consequent
      });
    }
    function switchStatement(discriminant, cases) {
      return (0, _validateNode.default)({
        type: "SwitchStatement",
        discriminant,
        cases
      });
    }
    function thisExpression() {
      return {
        type: "ThisExpression"
      };
    }
    function throwStatement(argument) {
      return (0, _validateNode.default)({
        type: "ThrowStatement",
        argument
      });
    }
    function tryStatement(block, handler = null, finalizer = null) {
      return (0, _validateNode.default)({
        type: "TryStatement",
        block,
        handler,
        finalizer
      });
    }
    function unaryExpression(operator, argument, prefix = true) {
      return (0, _validateNode.default)({
        type: "UnaryExpression",
        operator,
        argument,
        prefix
      });
    }
    function updateExpression(operator, argument, prefix = false) {
      return (0, _validateNode.default)({
        type: "UpdateExpression",
        operator,
        argument,
        prefix
      });
    }
    function variableDeclaration(kind, declarations) {
      return (0, _validateNode.default)({
        type: "VariableDeclaration",
        kind,
        declarations
      });
    }
    function variableDeclarator(id, init = null) {
      return (0, _validateNode.default)({
        type: "VariableDeclarator",
        id,
        init
      });
    }
    function whileStatement(test, body) {
      return (0, _validateNode.default)({
        type: "WhileStatement",
        test,
        body
      });
    }
    function withStatement(object, body) {
      return (0, _validateNode.default)({
        type: "WithStatement",
        object,
        body
      });
    }
    function assignmentPattern(left, right) {
      return (0, _validateNode.default)({
        type: "AssignmentPattern",
        left,
        right
      });
    }
    function arrayPattern(elements) {
      return (0, _validateNode.default)({
        type: "ArrayPattern",
        elements
      });
    }
    function arrowFunctionExpression(params, body, async = false) {
      return (0, _validateNode.default)({
        type: "ArrowFunctionExpression",
        params,
        body,
        async,
        expression: null
      });
    }
    function classBody(body) {
      return (0, _validateNode.default)({
        type: "ClassBody",
        body
      });
    }
    function classExpression(id = null, superClass = null, body, decorators = null) {
      return (0, _validateNode.default)({
        type: "ClassExpression",
        id,
        superClass,
        body,
        decorators
      });
    }
    function classDeclaration(id, superClass = null, body, decorators = null) {
      return (0, _validateNode.default)({
        type: "ClassDeclaration",
        id,
        superClass,
        body,
        decorators
      });
    }
    function exportAllDeclaration(source2) {
      return (0, _validateNode.default)({
        type: "ExportAllDeclaration",
        source: source2
      });
    }
    function exportDefaultDeclaration(declaration) {
      return (0, _validateNode.default)({
        type: "ExportDefaultDeclaration",
        declaration
      });
    }
    function exportNamedDeclaration(declaration = null, specifiers = [], source2 = null) {
      return (0, _validateNode.default)({
        type: "ExportNamedDeclaration",
        declaration,
        specifiers,
        source: source2
      });
    }
    function exportSpecifier(local, exported) {
      return (0, _validateNode.default)({
        type: "ExportSpecifier",
        local,
        exported
      });
    }
    function forOfStatement(left, right, body, _await = false) {
      return (0, _validateNode.default)({
        type: "ForOfStatement",
        left,
        right,
        body,
        await: _await
      });
    }
    function importDeclaration(specifiers, source2) {
      return (0, _validateNode.default)({
        type: "ImportDeclaration",
        specifiers,
        source: source2
      });
    }
    function importDefaultSpecifier(local) {
      return (0, _validateNode.default)({
        type: "ImportDefaultSpecifier",
        local
      });
    }
    function importNamespaceSpecifier(local) {
      return (0, _validateNode.default)({
        type: "ImportNamespaceSpecifier",
        local
      });
    }
    function importSpecifier(local, imported) {
      return (0, _validateNode.default)({
        type: "ImportSpecifier",
        local,
        imported
      });
    }
    function metaProperty(meta, property) {
      return (0, _validateNode.default)({
        type: "MetaProperty",
        meta,
        property
      });
    }
    function classMethod(kind = "method", key2, params, body, computed = false, _static = false, generator = false, async = false) {
      return (0, _validateNode.default)({
        type: "ClassMethod",
        kind,
        key: key2,
        params,
        body,
        computed,
        static: _static,
        generator,
        async
      });
    }
    function objectPattern(properties) {
      return (0, _validateNode.default)({
        type: "ObjectPattern",
        properties
      });
    }
    function spreadElement(argument) {
      return (0, _validateNode.default)({
        type: "SpreadElement",
        argument
      });
    }
    function _super() {
      return {
        type: "Super"
      };
    }
    function taggedTemplateExpression(tag, quasi) {
      return (0, _validateNode.default)({
        type: "TaggedTemplateExpression",
        tag,
        quasi
      });
    }
    function templateElement(value2, tail = false) {
      return (0, _validateNode.default)({
        type: "TemplateElement",
        value: value2,
        tail
      });
    }
    function templateLiteral(quasis, expressions) {
      return (0, _validateNode.default)({
        type: "TemplateLiteral",
        quasis,
        expressions
      });
    }
    function yieldExpression(argument = null, delegate = false) {
      return (0, _validateNode.default)({
        type: "YieldExpression",
        argument,
        delegate
      });
    }
    function awaitExpression(argument) {
      return (0, _validateNode.default)({
        type: "AwaitExpression",
        argument
      });
    }
    function _import() {
      return {
        type: "Import"
      };
    }
    function bigIntLiteral(value2) {
      return (0, _validateNode.default)({
        type: "BigIntLiteral",
        value: value2
      });
    }
    function exportNamespaceSpecifier(exported) {
      return (0, _validateNode.default)({
        type: "ExportNamespaceSpecifier",
        exported
      });
    }
    function optionalMemberExpression(object, property, computed = false, optional) {
      return (0, _validateNode.default)({
        type: "OptionalMemberExpression",
        object,
        property,
        computed,
        optional
      });
    }
    function optionalCallExpression(callee, _arguments, optional) {
      return (0, _validateNode.default)({
        type: "OptionalCallExpression",
        callee,
        arguments: _arguments,
        optional
      });
    }
    function classProperty(key2, value2 = null, typeAnnotation2 = null, decorators = null, computed = false, _static = false) {
      return (0, _validateNode.default)({
        type: "ClassProperty",
        key: key2,
        value: value2,
        typeAnnotation: typeAnnotation2,
        decorators,
        computed,
        static: _static
      });
    }
    function classAccessorProperty(key2, value2 = null, typeAnnotation2 = null, decorators = null, computed = false, _static = false) {
      return (0, _validateNode.default)({
        type: "ClassAccessorProperty",
        key: key2,
        value: value2,
        typeAnnotation: typeAnnotation2,
        decorators,
        computed,
        static: _static
      });
    }
    function classPrivateProperty(key2, value2 = null, decorators = null, _static = false) {
      return (0, _validateNode.default)({
        type: "ClassPrivateProperty",
        key: key2,
        value: value2,
        decorators,
        static: _static
      });
    }
    function classPrivateMethod(kind = "method", key2, params, body, _static = false) {
      return (0, _validateNode.default)({
        type: "ClassPrivateMethod",
        kind,
        key: key2,
        params,
        body,
        static: _static
      });
    }
    function privateName(id) {
      return (0, _validateNode.default)({
        type: "PrivateName",
        id
      });
    }
    function staticBlock(body) {
      return (0, _validateNode.default)({
        type: "StaticBlock",
        body
      });
    }
    function anyTypeAnnotation() {
      return {
        type: "AnyTypeAnnotation"
      };
    }
    function arrayTypeAnnotation(elementType) {
      return (0, _validateNode.default)({
        type: "ArrayTypeAnnotation",
        elementType
      });
    }
    function booleanTypeAnnotation() {
      return {
        type: "BooleanTypeAnnotation"
      };
    }
    function booleanLiteralTypeAnnotation(value2) {
      return (0, _validateNode.default)({
        type: "BooleanLiteralTypeAnnotation",
        value: value2
      });
    }
    function nullLiteralTypeAnnotation() {
      return {
        type: "NullLiteralTypeAnnotation"
      };
    }
    function classImplements(id, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "ClassImplements",
        id,
        typeParameters
      });
    }
    function declareClass(id, typeParameters = null, _extends = null, body) {
      return (0, _validateNode.default)({
        type: "DeclareClass",
        id,
        typeParameters,
        extends: _extends,
        body
      });
    }
    function declareFunction(id) {
      return (0, _validateNode.default)({
        type: "DeclareFunction",
        id
      });
    }
    function declareInterface(id, typeParameters = null, _extends = null, body) {
      return (0, _validateNode.default)({
        type: "DeclareInterface",
        id,
        typeParameters,
        extends: _extends,
        body
      });
    }
    function declareModule(id, body, kind = null) {
      return (0, _validateNode.default)({
        type: "DeclareModule",
        id,
        body,
        kind
      });
    }
    function declareModuleExports(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "DeclareModuleExports",
        typeAnnotation: typeAnnotation2
      });
    }
    function declareTypeAlias(id, typeParameters = null, right) {
      return (0, _validateNode.default)({
        type: "DeclareTypeAlias",
        id,
        typeParameters,
        right
      });
    }
    function declareOpaqueType(id, typeParameters = null, supertype = null) {
      return (0, _validateNode.default)({
        type: "DeclareOpaqueType",
        id,
        typeParameters,
        supertype
      });
    }
    function declareVariable(id) {
      return (0, _validateNode.default)({
        type: "DeclareVariable",
        id
      });
    }
    function declareExportDeclaration(declaration = null, specifiers = null, source2 = null) {
      return (0, _validateNode.default)({
        type: "DeclareExportDeclaration",
        declaration,
        specifiers,
        source: source2
      });
    }
    function declareExportAllDeclaration(source2) {
      return (0, _validateNode.default)({
        type: "DeclareExportAllDeclaration",
        source: source2
      });
    }
    function declaredPredicate(value2) {
      return (0, _validateNode.default)({
        type: "DeclaredPredicate",
        value: value2
      });
    }
    function existsTypeAnnotation() {
      return {
        type: "ExistsTypeAnnotation"
      };
    }
    function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
      return (0, _validateNode.default)({
        type: "FunctionTypeAnnotation",
        typeParameters,
        params,
        rest,
        returnType
      });
    }
    function functionTypeParam(name2 = null, typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "FunctionTypeParam",
        name: name2,
        typeAnnotation: typeAnnotation2
      });
    }
    function genericTypeAnnotation(id, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "GenericTypeAnnotation",
        id,
        typeParameters
      });
    }
    function inferredPredicate() {
      return {
        type: "InferredPredicate"
      };
    }
    function interfaceExtends(id, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "InterfaceExtends",
        id,
        typeParameters
      });
    }
    function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
      return (0, _validateNode.default)({
        type: "InterfaceDeclaration",
        id,
        typeParameters,
        extends: _extends,
        body
      });
    }
    function interfaceTypeAnnotation(_extends = null, body) {
      return (0, _validateNode.default)({
        type: "InterfaceTypeAnnotation",
        extends: _extends,
        body
      });
    }
    function intersectionTypeAnnotation(types3) {
      return (0, _validateNode.default)({
        type: "IntersectionTypeAnnotation",
        types: types3
      });
    }
    function mixedTypeAnnotation() {
      return {
        type: "MixedTypeAnnotation"
      };
    }
    function emptyTypeAnnotation() {
      return {
        type: "EmptyTypeAnnotation"
      };
    }
    function nullableTypeAnnotation(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "NullableTypeAnnotation",
        typeAnnotation: typeAnnotation2
      });
    }
    function numberLiteralTypeAnnotation(value2) {
      return (0, _validateNode.default)({
        type: "NumberLiteralTypeAnnotation",
        value: value2
      });
    }
    function numberTypeAnnotation() {
      return {
        type: "NumberTypeAnnotation"
      };
    }
    function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
      return (0, _validateNode.default)({
        type: "ObjectTypeAnnotation",
        properties,
        indexers,
        callProperties,
        internalSlots,
        exact
      });
    }
    function objectTypeInternalSlot(id, value2, optional, _static, method) {
      return (0, _validateNode.default)({
        type: "ObjectTypeInternalSlot",
        id,
        value: value2,
        optional,
        static: _static,
        method
      });
    }
    function objectTypeCallProperty(value2) {
      return (0, _validateNode.default)({
        type: "ObjectTypeCallProperty",
        value: value2,
        static: null
      });
    }
    function objectTypeIndexer(id = null, key2, value2, variance2 = null) {
      return (0, _validateNode.default)({
        type: "ObjectTypeIndexer",
        id,
        key: key2,
        value: value2,
        variance: variance2,
        static: null
      });
    }
    function objectTypeProperty(key2, value2, variance2 = null) {
      return (0, _validateNode.default)({
        type: "ObjectTypeProperty",
        key: key2,
        value: value2,
        variance: variance2,
        kind: null,
        method: null,
        optional: null,
        proto: null,
        static: null
      });
    }
    function objectTypeSpreadProperty(argument) {
      return (0, _validateNode.default)({
        type: "ObjectTypeSpreadProperty",
        argument
      });
    }
    function opaqueType(id, typeParameters = null, supertype = null, impltype) {
      return (0, _validateNode.default)({
        type: "OpaqueType",
        id,
        typeParameters,
        supertype,
        impltype
      });
    }
    function qualifiedTypeIdentifier(id, qualification) {
      return (0, _validateNode.default)({
        type: "QualifiedTypeIdentifier",
        id,
        qualification
      });
    }
    function stringLiteralTypeAnnotation(value2) {
      return (0, _validateNode.default)({
        type: "StringLiteralTypeAnnotation",
        value: value2
      });
    }
    function stringTypeAnnotation() {
      return {
        type: "StringTypeAnnotation"
      };
    }
    function symbolTypeAnnotation() {
      return {
        type: "SymbolTypeAnnotation"
      };
    }
    function thisTypeAnnotation() {
      return {
        type: "ThisTypeAnnotation"
      };
    }
    function tupleTypeAnnotation(types3) {
      return (0, _validateNode.default)({
        type: "TupleTypeAnnotation",
        types: types3
      });
    }
    function typeofTypeAnnotation(argument) {
      return (0, _validateNode.default)({
        type: "TypeofTypeAnnotation",
        argument
      });
    }
    function typeAlias(id, typeParameters = null, right) {
      return (0, _validateNode.default)({
        type: "TypeAlias",
        id,
        typeParameters,
        right
      });
    }
    function typeAnnotation(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TypeAnnotation",
        typeAnnotation: typeAnnotation2
      });
    }
    function typeCastExpression(expression, typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TypeCastExpression",
        expression,
        typeAnnotation: typeAnnotation2
      });
    }
    function typeParameter(bound = null, _default = null, variance2 = null) {
      return (0, _validateNode.default)({
        type: "TypeParameter",
        bound,
        default: _default,
        variance: variance2,
        name: null
      });
    }
    function typeParameterDeclaration(params) {
      return (0, _validateNode.default)({
        type: "TypeParameterDeclaration",
        params
      });
    }
    function typeParameterInstantiation(params) {
      return (0, _validateNode.default)({
        type: "TypeParameterInstantiation",
        params
      });
    }
    function unionTypeAnnotation(types3) {
      return (0, _validateNode.default)({
        type: "UnionTypeAnnotation",
        types: types3
      });
    }
    function variance(kind) {
      return (0, _validateNode.default)({
        type: "Variance",
        kind
      });
    }
    function voidTypeAnnotation() {
      return {
        type: "VoidTypeAnnotation"
      };
    }
    function enumDeclaration(id, body) {
      return (0, _validateNode.default)({
        type: "EnumDeclaration",
        id,
        body
      });
    }
    function enumBooleanBody(members) {
      return (0, _validateNode.default)({
        type: "EnumBooleanBody",
        members,
        explicitType: null,
        hasUnknownMembers: null
      });
    }
    function enumNumberBody(members) {
      return (0, _validateNode.default)({
        type: "EnumNumberBody",
        members,
        explicitType: null,
        hasUnknownMembers: null
      });
    }
    function enumStringBody(members) {
      return (0, _validateNode.default)({
        type: "EnumStringBody",
        members,
        explicitType: null,
        hasUnknownMembers: null
      });
    }
    function enumSymbolBody(members) {
      return (0, _validateNode.default)({
        type: "EnumSymbolBody",
        members,
        hasUnknownMembers: null
      });
    }
    function enumBooleanMember(id) {
      return (0, _validateNode.default)({
        type: "EnumBooleanMember",
        id,
        init: null
      });
    }
    function enumNumberMember(id, init) {
      return (0, _validateNode.default)({
        type: "EnumNumberMember",
        id,
        init
      });
    }
    function enumStringMember(id, init) {
      return (0, _validateNode.default)({
        type: "EnumStringMember",
        id,
        init
      });
    }
    function enumDefaultedMember(id) {
      return (0, _validateNode.default)({
        type: "EnumDefaultedMember",
        id
      });
    }
    function indexedAccessType(objectType, indexType) {
      return (0, _validateNode.default)({
        type: "IndexedAccessType",
        objectType,
        indexType
      });
    }
    function optionalIndexedAccessType(objectType, indexType) {
      return (0, _validateNode.default)({
        type: "OptionalIndexedAccessType",
        objectType,
        indexType,
        optional: null
      });
    }
    function jsxAttribute2(name2, value2 = null) {
      return (0, _validateNode.default)({
        type: "JSXAttribute",
        name: name2,
        value: value2
      });
    }
    function jsxClosingElement(name2) {
      return (0, _validateNode.default)({
        type: "JSXClosingElement",
        name: name2
      });
    }
    function jsxElement(openingElement, closingElement = null, children, selfClosing = null) {
      return (0, _validateNode.default)({
        type: "JSXElement",
        openingElement,
        closingElement,
        children,
        selfClosing
      });
    }
    function jsxEmptyExpression() {
      return {
        type: "JSXEmptyExpression"
      };
    }
    function jsxExpressionContainer(expression) {
      return (0, _validateNode.default)({
        type: "JSXExpressionContainer",
        expression
      });
    }
    function jsxSpreadChild(expression) {
      return (0, _validateNode.default)({
        type: "JSXSpreadChild",
        expression
      });
    }
    function jsxIdentifier2(name2) {
      return (0, _validateNode.default)({
        type: "JSXIdentifier",
        name: name2
      });
    }
    function jsxMemberExpression(object, property) {
      return (0, _validateNode.default)({
        type: "JSXMemberExpression",
        object,
        property
      });
    }
    function jsxNamespacedName(namespace, name2) {
      return (0, _validateNode.default)({
        type: "JSXNamespacedName",
        namespace,
        name: name2
      });
    }
    function jsxOpeningElement(name2, attributes, selfClosing = false) {
      return (0, _validateNode.default)({
        type: "JSXOpeningElement",
        name: name2,
        attributes,
        selfClosing
      });
    }
    function jsxSpreadAttribute(argument) {
      return (0, _validateNode.default)({
        type: "JSXSpreadAttribute",
        argument
      });
    }
    function jsxText2(value2) {
      return (0, _validateNode.default)({
        type: "JSXText",
        value: value2
      });
    }
    function jsxFragment(openingFragment, closingFragment, children) {
      return (0, _validateNode.default)({
        type: "JSXFragment",
        openingFragment,
        closingFragment,
        children
      });
    }
    function jsxOpeningFragment() {
      return {
        type: "JSXOpeningFragment"
      };
    }
    function jsxClosingFragment() {
      return {
        type: "JSXClosingFragment"
      };
    }
    function noop() {
      return {
        type: "Noop"
      };
    }
    function placeholder(expectedNode, name2) {
      return (0, _validateNode.default)({
        type: "Placeholder",
        expectedNode,
        name: name2
      });
    }
    function v8IntrinsicIdentifier(name2) {
      return (0, _validateNode.default)({
        type: "V8IntrinsicIdentifier",
        name: name2
      });
    }
    function argumentPlaceholder() {
      return {
        type: "ArgumentPlaceholder"
      };
    }
    function bindExpression(object, callee) {
      return (0, _validateNode.default)({
        type: "BindExpression",
        object,
        callee
      });
    }
    function importAttribute(key2, value2) {
      return (0, _validateNode.default)({
        type: "ImportAttribute",
        key: key2,
        value: value2
      });
    }
    function decorator(expression) {
      return (0, _validateNode.default)({
        type: "Decorator",
        expression
      });
    }
    function doExpression(body, async = false) {
      return (0, _validateNode.default)({
        type: "DoExpression",
        body,
        async
      });
    }
    function exportDefaultSpecifier(exported) {
      return (0, _validateNode.default)({
        type: "ExportDefaultSpecifier",
        exported
      });
    }
    function recordExpression(properties) {
      return (0, _validateNode.default)({
        type: "RecordExpression",
        properties
      });
    }
    function tupleExpression(elements = []) {
      return (0, _validateNode.default)({
        type: "TupleExpression",
        elements
      });
    }
    function decimalLiteral(value2) {
      return (0, _validateNode.default)({
        type: "DecimalLiteral",
        value: value2
      });
    }
    function moduleExpression(body) {
      return (0, _validateNode.default)({
        type: "ModuleExpression",
        body
      });
    }
    function topicReference() {
      return {
        type: "TopicReference"
      };
    }
    function pipelineTopicExpression(expression) {
      return (0, _validateNode.default)({
        type: "PipelineTopicExpression",
        expression
      });
    }
    function pipelineBareFunction(callee) {
      return (0, _validateNode.default)({
        type: "PipelineBareFunction",
        callee
      });
    }
    function pipelinePrimaryTopicReference() {
      return {
        type: "PipelinePrimaryTopicReference"
      };
    }
    function tsParameterProperty(parameter) {
      return (0, _validateNode.default)({
        type: "TSParameterProperty",
        parameter
      });
    }
    function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
      return (0, _validateNode.default)({
        type: "TSDeclareFunction",
        id,
        typeParameters,
        params,
        returnType
      });
    }
    function tsDeclareMethod(decorators = null, key2, typeParameters = null, params, returnType = null) {
      return (0, _validateNode.default)({
        type: "TSDeclareMethod",
        decorators,
        key: key2,
        typeParameters,
        params,
        returnType
      });
    }
    function tsQualifiedName(left, right) {
      return (0, _validateNode.default)({
        type: "TSQualifiedName",
        left,
        right
      });
    }
    function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation2 = null) {
      return (0, _validateNode.default)({
        type: "TSCallSignatureDeclaration",
        typeParameters,
        parameters,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation2 = null) {
      return (0, _validateNode.default)({
        type: "TSConstructSignatureDeclaration",
        typeParameters,
        parameters,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsPropertySignature(key2, typeAnnotation2 = null, initializer = null) {
      return (0, _validateNode.default)({
        type: "TSPropertySignature",
        key: key2,
        typeAnnotation: typeAnnotation2,
        initializer,
        kind: null
      });
    }
    function tsMethodSignature(key2, typeParameters = null, parameters, typeAnnotation2 = null) {
      return (0, _validateNode.default)({
        type: "TSMethodSignature",
        key: key2,
        typeParameters,
        parameters,
        typeAnnotation: typeAnnotation2,
        kind: null
      });
    }
    function tsIndexSignature(parameters, typeAnnotation2 = null) {
      return (0, _validateNode.default)({
        type: "TSIndexSignature",
        parameters,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsAnyKeyword() {
      return {
        type: "TSAnyKeyword"
      };
    }
    function tsBooleanKeyword() {
      return {
        type: "TSBooleanKeyword"
      };
    }
    function tsBigIntKeyword() {
      return {
        type: "TSBigIntKeyword"
      };
    }
    function tsIntrinsicKeyword() {
      return {
        type: "TSIntrinsicKeyword"
      };
    }
    function tsNeverKeyword() {
      return {
        type: "TSNeverKeyword"
      };
    }
    function tsNullKeyword() {
      return {
        type: "TSNullKeyword"
      };
    }
    function tsNumberKeyword() {
      return {
        type: "TSNumberKeyword"
      };
    }
    function tsObjectKeyword() {
      return {
        type: "TSObjectKeyword"
      };
    }
    function tsStringKeyword() {
      return {
        type: "TSStringKeyword"
      };
    }
    function tsSymbolKeyword() {
      return {
        type: "TSSymbolKeyword"
      };
    }
    function tsUndefinedKeyword() {
      return {
        type: "TSUndefinedKeyword"
      };
    }
    function tsUnknownKeyword() {
      return {
        type: "TSUnknownKeyword"
      };
    }
    function tsVoidKeyword() {
      return {
        type: "TSVoidKeyword"
      };
    }
    function tsThisType() {
      return {
        type: "TSThisType"
      };
    }
    function tsFunctionType(typeParameters = null, parameters, typeAnnotation2 = null) {
      return (0, _validateNode.default)({
        type: "TSFunctionType",
        typeParameters,
        parameters,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsConstructorType(typeParameters = null, parameters, typeAnnotation2 = null) {
      return (0, _validateNode.default)({
        type: "TSConstructorType",
        typeParameters,
        parameters,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsTypeReference(typeName, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "TSTypeReference",
        typeName,
        typeParameters
      });
    }
    function tsTypePredicate(parameterName, typeAnnotation2 = null, asserts = null) {
      return (0, _validateNode.default)({
        type: "TSTypePredicate",
        parameterName,
        typeAnnotation: typeAnnotation2,
        asserts
      });
    }
    function tsTypeQuery(exprName, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "TSTypeQuery",
        exprName,
        typeParameters
      });
    }
    function tsTypeLiteral(members) {
      return (0, _validateNode.default)({
        type: "TSTypeLiteral",
        members
      });
    }
    function tsArrayType(elementType) {
      return (0, _validateNode.default)({
        type: "TSArrayType",
        elementType
      });
    }
    function tsTupleType(elementTypes) {
      return (0, _validateNode.default)({
        type: "TSTupleType",
        elementTypes
      });
    }
    function tsOptionalType(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSOptionalType",
        typeAnnotation: typeAnnotation2
      });
    }
    function tsRestType(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSRestType",
        typeAnnotation: typeAnnotation2
      });
    }
    function tsNamedTupleMember(label, elementType, optional = false) {
      return (0, _validateNode.default)({
        type: "TSNamedTupleMember",
        label,
        elementType,
        optional
      });
    }
    function tsUnionType(types3) {
      return (0, _validateNode.default)({
        type: "TSUnionType",
        types: types3
      });
    }
    function tsIntersectionType(types3) {
      return (0, _validateNode.default)({
        type: "TSIntersectionType",
        types: types3
      });
    }
    function tsConditionalType(checkType, extendsType, trueType, falseType) {
      return (0, _validateNode.default)({
        type: "TSConditionalType",
        checkType,
        extendsType,
        trueType,
        falseType
      });
    }
    function tsInferType(typeParameter2) {
      return (0, _validateNode.default)({
        type: "TSInferType",
        typeParameter: typeParameter2
      });
    }
    function tsParenthesizedType(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSParenthesizedType",
        typeAnnotation: typeAnnotation2
      });
    }
    function tsTypeOperator(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSTypeOperator",
        typeAnnotation: typeAnnotation2,
        operator: null
      });
    }
    function tsIndexedAccessType(objectType, indexType) {
      return (0, _validateNode.default)({
        type: "TSIndexedAccessType",
        objectType,
        indexType
      });
    }
    function tsMappedType(typeParameter2, typeAnnotation2 = null, nameType = null) {
      return (0, _validateNode.default)({
        type: "TSMappedType",
        typeParameter: typeParameter2,
        typeAnnotation: typeAnnotation2,
        nameType
      });
    }
    function tsLiteralType(literal4) {
      return (0, _validateNode.default)({
        type: "TSLiteralType",
        literal: literal4
      });
    }
    function tsExpressionWithTypeArguments(expression, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "TSExpressionWithTypeArguments",
        expression,
        typeParameters
      });
    }
    function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
      return (0, _validateNode.default)({
        type: "TSInterfaceDeclaration",
        id,
        typeParameters,
        extends: _extends,
        body
      });
    }
    function tsInterfaceBody(body) {
      return (0, _validateNode.default)({
        type: "TSInterfaceBody",
        body
      });
    }
    function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSTypeAliasDeclaration",
        id,
        typeParameters,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsInstantiationExpression(expression, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "TSInstantiationExpression",
        expression,
        typeParameters
      });
    }
    function tsAsExpression(expression, typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSAsExpression",
        expression,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsSatisfiesExpression(expression, typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSSatisfiesExpression",
        expression,
        typeAnnotation: typeAnnotation2
      });
    }
    function tsTypeAssertion(typeAnnotation2, expression) {
      return (0, _validateNode.default)({
        type: "TSTypeAssertion",
        typeAnnotation: typeAnnotation2,
        expression
      });
    }
    function tsEnumDeclaration(id, members) {
      return (0, _validateNode.default)({
        type: "TSEnumDeclaration",
        id,
        members
      });
    }
    function tsEnumMember(id, initializer = null) {
      return (0, _validateNode.default)({
        type: "TSEnumMember",
        id,
        initializer
      });
    }
    function tsModuleDeclaration(id, body) {
      return (0, _validateNode.default)({
        type: "TSModuleDeclaration",
        id,
        body
      });
    }
    function tsModuleBlock(body) {
      return (0, _validateNode.default)({
        type: "TSModuleBlock",
        body
      });
    }
    function tsImportType(argument, qualifier = null, typeParameters = null) {
      return (0, _validateNode.default)({
        type: "TSImportType",
        argument,
        qualifier,
        typeParameters
      });
    }
    function tsImportEqualsDeclaration(id, moduleReference) {
      return (0, _validateNode.default)({
        type: "TSImportEqualsDeclaration",
        id,
        moduleReference,
        isExport: null
      });
    }
    function tsExternalModuleReference(expression) {
      return (0, _validateNode.default)({
        type: "TSExternalModuleReference",
        expression
      });
    }
    function tsNonNullExpression(expression) {
      return (0, _validateNode.default)({
        type: "TSNonNullExpression",
        expression
      });
    }
    function tsExportAssignment(expression) {
      return (0, _validateNode.default)({
        type: "TSExportAssignment",
        expression
      });
    }
    function tsNamespaceExportDeclaration(id) {
      return (0, _validateNode.default)({
        type: "TSNamespaceExportDeclaration",
        id
      });
    }
    function tsTypeAnnotation(typeAnnotation2) {
      return (0, _validateNode.default)({
        type: "TSTypeAnnotation",
        typeAnnotation: typeAnnotation2
      });
    }
    function tsTypeParameterInstantiation(params) {
      return (0, _validateNode.default)({
        type: "TSTypeParameterInstantiation",
        params
      });
    }
    function tsTypeParameterDeclaration(params) {
      return (0, _validateNode.default)({
        type: "TSTypeParameterDeclaration",
        params
      });
    }
    function tsTypeParameter(constraint = null, _default = null, name2) {
      return (0, _validateNode.default)({
        type: "TSTypeParameter",
        constraint,
        default: _default,
        name: name2
      });
    }
    function NumberLiteral(value2) {
      (0, _deprecationWarning.default)("NumberLiteral", "NumericLiteral", "The node type ");
      return numericLiteral(value2);
    }
    function RegexLiteral(pattern, flags = "") {
      (0, _deprecationWarning.default)("RegexLiteral", "RegExpLiteral", "The node type ");
      return regExpLiteral(pattern, flags);
    }
    function RestProperty(argument) {
      (0, _deprecationWarning.default)("RestProperty", "RestElement", "The node type ");
      return restElement(argument);
    }
    function SpreadProperty(argument) {
      (0, _deprecationWarning.default)("SpreadProperty", "SpreadElement", "The node type ");
      return spreadElement(argument);
    }
  }
});

// node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js
var require_cleanJSXElementLiteralChild = __commonJS({
  "node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = cleanJSXElementLiteralChild;
    var _generated = require_generated2();
    var _ = require_lib3();
    function cleanJSXElementLiteralChild(child, args) {
      const lines = child.value.split(/\r\n|\n|\r/);
      let lastNonEmptyLine = 0;
      for (let i = 0; i < lines.length; i++) {
        if (lines[i].match(/[^ \t]/)) {
          lastNonEmptyLine = i;
        }
      }
      let str = "";
      for (let i = 0; i < lines.length; i++) {
        const line2 = lines[i];
        const isFirstLine = i === 0;
        const isLastLine = i === lines.length - 1;
        const isLastNonEmptyLine = i === lastNonEmptyLine;
        let trimmedLine = line2.replace(/\t/g, " ");
        if (!isFirstLine) {
          trimmedLine = trimmedLine.replace(/^[ ]+/, "");
        }
        if (!isLastLine) {
          trimmedLine = trimmedLine.replace(/[ ]+$/, "");
        }
        if (trimmedLine) {
          if (!isLastNonEmptyLine) {
            trimmedLine += " ";
          }
          str += trimmedLine;
        }
      }
      if (str)
        args.push((0, _.inherits)((0, _generated.stringLiteral)(str), child));
    }
  }
});

// node_modules/@babel/types/lib/builders/react/buildChildren.js
var require_buildChildren = __commonJS({
  "node_modules/@babel/types/lib/builders/react/buildChildren.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = buildChildren;
    var _generated = require_generated();
    var _cleanJSXElementLiteralChild = require_cleanJSXElementLiteralChild();
    function buildChildren(node2) {
      const elements = [];
      for (let i = 0; i < node2.children.length; i++) {
        let child = node2.children[i];
        if ((0, _generated.isJSXText)(child)) {
          (0, _cleanJSXElementLiteralChild.default)(child, elements);
          continue;
        }
        if ((0, _generated.isJSXExpressionContainer)(child))
          child = child.expression;
        if ((0, _generated.isJSXEmptyExpression)(child))
          continue;
        elements.push(child);
      }
      return elements;
    }
  }
});

// node_modules/@babel/types/lib/validators/isNode.js
var require_isNode = __commonJS({
  "node_modules/@babel/types/lib/validators/isNode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isNode2;
    var _definitions = require_definitions();
    function isNode2(node2) {
      return !!(node2 && _definitions.VISITOR_KEYS[node2.type]);
    }
  }
});

// node_modules/@babel/types/lib/asserts/assertNode.js
var require_assertNode = __commonJS({
  "node_modules/@babel/types/lib/asserts/assertNode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = assertNode2;
    var _isNode = require_isNode();
    function assertNode2(node2) {
      if (!(0, _isNode.default)(node2)) {
        var _node$type;
        const type = (_node$type = node2 == null ? void 0 : node2.type) != null ? _node$type : JSON.stringify(node2);
        throw new TypeError(`Not a valid node of type "${type}"`);
      }
    }
  }
});

// node_modules/@babel/types/lib/asserts/generated/index.js
var require_generated3 = __commonJS({
  "node_modules/@babel/types/lib/asserts/generated/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.assertAccessor = assertAccessor;
    exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
    exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
    exports.assertArrayExpression = assertArrayExpression;
    exports.assertArrayPattern = assertArrayPattern;
    exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
    exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
    exports.assertAssignmentExpression = assertAssignmentExpression;
    exports.assertAssignmentPattern = assertAssignmentPattern;
    exports.assertAwaitExpression = assertAwaitExpression;
    exports.assertBigIntLiteral = assertBigIntLiteral;
    exports.assertBinary = assertBinary;
    exports.assertBinaryExpression = assertBinaryExpression;
    exports.assertBindExpression = assertBindExpression;
    exports.assertBlock = assertBlock;
    exports.assertBlockParent = assertBlockParent;
    exports.assertBlockStatement = assertBlockStatement;
    exports.assertBooleanLiteral = assertBooleanLiteral;
    exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
    exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
    exports.assertBreakStatement = assertBreakStatement;
    exports.assertCallExpression = assertCallExpression;
    exports.assertCatchClause = assertCatchClause;
    exports.assertClass = assertClass;
    exports.assertClassAccessorProperty = assertClassAccessorProperty;
    exports.assertClassBody = assertClassBody;
    exports.assertClassDeclaration = assertClassDeclaration;
    exports.assertClassExpression = assertClassExpression;
    exports.assertClassImplements = assertClassImplements;
    exports.assertClassMethod = assertClassMethod;
    exports.assertClassPrivateMethod = assertClassPrivateMethod;
    exports.assertClassPrivateProperty = assertClassPrivateProperty;
    exports.assertClassProperty = assertClassProperty;
    exports.assertCompletionStatement = assertCompletionStatement;
    exports.assertConditional = assertConditional;
    exports.assertConditionalExpression = assertConditionalExpression;
    exports.assertContinueStatement = assertContinueStatement;
    exports.assertDebuggerStatement = assertDebuggerStatement;
    exports.assertDecimalLiteral = assertDecimalLiteral;
    exports.assertDeclaration = assertDeclaration;
    exports.assertDeclareClass = assertDeclareClass;
    exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
    exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
    exports.assertDeclareFunction = assertDeclareFunction;
    exports.assertDeclareInterface = assertDeclareInterface;
    exports.assertDeclareModule = assertDeclareModule;
    exports.assertDeclareModuleExports = assertDeclareModuleExports;
    exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
    exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
    exports.assertDeclareVariable = assertDeclareVariable;
    exports.assertDeclaredPredicate = assertDeclaredPredicate;
    exports.assertDecorator = assertDecorator;
    exports.assertDirective = assertDirective;
    exports.assertDirectiveLiteral = assertDirectiveLiteral;
    exports.assertDoExpression = assertDoExpression;
    exports.assertDoWhileStatement = assertDoWhileStatement;
    exports.assertEmptyStatement = assertEmptyStatement;
    exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
    exports.assertEnumBody = assertEnumBody;
    exports.assertEnumBooleanBody = assertEnumBooleanBody;
    exports.assertEnumBooleanMember = assertEnumBooleanMember;
    exports.assertEnumDeclaration = assertEnumDeclaration;
    exports.assertEnumDefaultedMember = assertEnumDefaultedMember;
    exports.assertEnumMember = assertEnumMember;
    exports.assertEnumNumberBody = assertEnumNumberBody;
    exports.assertEnumNumberMember = assertEnumNumberMember;
    exports.assertEnumStringBody = assertEnumStringBody;
    exports.assertEnumStringMember = assertEnumStringMember;
    exports.assertEnumSymbolBody = assertEnumSymbolBody;
    exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
    exports.assertExportAllDeclaration = assertExportAllDeclaration;
    exports.assertExportDeclaration = assertExportDeclaration;
    exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
    exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
    exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
    exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
    exports.assertExportSpecifier = assertExportSpecifier;
    exports.assertExpression = assertExpression;
    exports.assertExpressionStatement = assertExpressionStatement;
    exports.assertExpressionWrapper = assertExpressionWrapper;
    exports.assertFile = assertFile;
    exports.assertFlow = assertFlow;
    exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
    exports.assertFlowDeclaration = assertFlowDeclaration;
    exports.assertFlowPredicate = assertFlowPredicate;
    exports.assertFlowType = assertFlowType;
    exports.assertFor = assertFor;
    exports.assertForInStatement = assertForInStatement;
    exports.assertForOfStatement = assertForOfStatement;
    exports.assertForStatement = assertForStatement;
    exports.assertForXStatement = assertForXStatement;
    exports.assertFunction = assertFunction;
    exports.assertFunctionDeclaration = assertFunctionDeclaration;
    exports.assertFunctionExpression = assertFunctionExpression;
    exports.assertFunctionParent = assertFunctionParent;
    exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
    exports.assertFunctionTypeParam = assertFunctionTypeParam;
    exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
    exports.assertIdentifier = assertIdentifier;
    exports.assertIfStatement = assertIfStatement;
    exports.assertImmutable = assertImmutable;
    exports.assertImport = assertImport;
    exports.assertImportAttribute = assertImportAttribute;
    exports.assertImportDeclaration = assertImportDeclaration;
    exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
    exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
    exports.assertImportOrExportDeclaration = assertImportOrExportDeclaration;
    exports.assertImportSpecifier = assertImportSpecifier;
    exports.assertIndexedAccessType = assertIndexedAccessType;
    exports.assertInferredPredicate = assertInferredPredicate;
    exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
    exports.assertInterfaceExtends = assertInterfaceExtends;
    exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
    exports.assertInterpreterDirective = assertInterpreterDirective;
    exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
    exports.assertJSX = assertJSX;
    exports.assertJSXAttribute = assertJSXAttribute;
    exports.assertJSXClosingElement = assertJSXClosingElement;
    exports.assertJSXClosingFragment = assertJSXClosingFragment;
    exports.assertJSXElement = assertJSXElement;
    exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
    exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
    exports.assertJSXFragment = assertJSXFragment;
    exports.assertJSXIdentifier = assertJSXIdentifier;
    exports.assertJSXMemberExpression = assertJSXMemberExpression;
    exports.assertJSXNamespacedName = assertJSXNamespacedName;
    exports.assertJSXOpeningElement = assertJSXOpeningElement;
    exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
    exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
    exports.assertJSXSpreadChild = assertJSXSpreadChild;
    exports.assertJSXText = assertJSXText;
    exports.assertLVal = assertLVal;
    exports.assertLabeledStatement = assertLabeledStatement;
    exports.assertLiteral = assertLiteral;
    exports.assertLogicalExpression = assertLogicalExpression;
    exports.assertLoop = assertLoop;
    exports.assertMemberExpression = assertMemberExpression;
    exports.assertMetaProperty = assertMetaProperty;
    exports.assertMethod = assertMethod;
    exports.assertMiscellaneous = assertMiscellaneous;
    exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
    exports.assertModuleDeclaration = assertModuleDeclaration;
    exports.assertModuleExpression = assertModuleExpression;
    exports.assertModuleSpecifier = assertModuleSpecifier;
    exports.assertNewExpression = assertNewExpression;
    exports.assertNoop = assertNoop;
    exports.assertNullLiteral = assertNullLiteral;
    exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
    exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
    exports.assertNumberLiteral = assertNumberLiteral;
    exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
    exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
    exports.assertNumericLiteral = assertNumericLiteral;
    exports.assertObjectExpression = assertObjectExpression;
    exports.assertObjectMember = assertObjectMember;
    exports.assertObjectMethod = assertObjectMethod;
    exports.assertObjectPattern = assertObjectPattern;
    exports.assertObjectProperty = assertObjectProperty;
    exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
    exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
    exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
    exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
    exports.assertObjectTypeProperty = assertObjectTypeProperty;
    exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
    exports.assertOpaqueType = assertOpaqueType;
    exports.assertOptionalCallExpression = assertOptionalCallExpression;
    exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;
    exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
    exports.assertParenthesizedExpression = assertParenthesizedExpression;
    exports.assertPattern = assertPattern;
    exports.assertPatternLike = assertPatternLike;
    exports.assertPipelineBareFunction = assertPipelineBareFunction;
    exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
    exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
    exports.assertPlaceholder = assertPlaceholder;
    exports.assertPrivate = assertPrivate;
    exports.assertPrivateName = assertPrivateName;
    exports.assertProgram = assertProgram;
    exports.assertProperty = assertProperty;
    exports.assertPureish = assertPureish;
    exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
    exports.assertRecordExpression = assertRecordExpression;
    exports.assertRegExpLiteral = assertRegExpLiteral;
    exports.assertRegexLiteral = assertRegexLiteral;
    exports.assertRestElement = assertRestElement;
    exports.assertRestProperty = assertRestProperty;
    exports.assertReturnStatement = assertReturnStatement;
    exports.assertScopable = assertScopable;
    exports.assertSequenceExpression = assertSequenceExpression;
    exports.assertSpreadElement = assertSpreadElement;
    exports.assertSpreadProperty = assertSpreadProperty;
    exports.assertStandardized = assertStandardized;
    exports.assertStatement = assertStatement;
    exports.assertStaticBlock = assertStaticBlock;
    exports.assertStringLiteral = assertStringLiteral;
    exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
    exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
    exports.assertSuper = assertSuper;
    exports.assertSwitchCase = assertSwitchCase;
    exports.assertSwitchStatement = assertSwitchStatement;
    exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
    exports.assertTSAnyKeyword = assertTSAnyKeyword;
    exports.assertTSArrayType = assertTSArrayType;
    exports.assertTSAsExpression = assertTSAsExpression;
    exports.assertTSBaseType = assertTSBaseType;
    exports.assertTSBigIntKeyword = assertTSBigIntKeyword;
    exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
    exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
    exports.assertTSConditionalType = assertTSConditionalType;
    exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
    exports.assertTSConstructorType = assertTSConstructorType;
    exports.assertTSDeclareFunction = assertTSDeclareFunction;
    exports.assertTSDeclareMethod = assertTSDeclareMethod;
    exports.assertTSEntityName = assertTSEntityName;
    exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
    exports.assertTSEnumMember = assertTSEnumMember;
    exports.assertTSExportAssignment = assertTSExportAssignment;
    exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
    exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
    exports.assertTSFunctionType = assertTSFunctionType;
    exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
    exports.assertTSImportType = assertTSImportType;
    exports.assertTSIndexSignature = assertTSIndexSignature;
    exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
    exports.assertTSInferType = assertTSInferType;
    exports.assertTSInstantiationExpression = assertTSInstantiationExpression;
    exports.assertTSInterfaceBody = assertTSInterfaceBody;
    exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
    exports.assertTSIntersectionType = assertTSIntersectionType;
    exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
    exports.assertTSLiteralType = assertTSLiteralType;
    exports.assertTSMappedType = assertTSMappedType;
    exports.assertTSMethodSignature = assertTSMethodSignature;
    exports.assertTSModuleBlock = assertTSModuleBlock;
    exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
    exports.assertTSNamedTupleMember = assertTSNamedTupleMember;
    exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
    exports.assertTSNeverKeyword = assertTSNeverKeyword;
    exports.assertTSNonNullExpression = assertTSNonNullExpression;
    exports.assertTSNullKeyword = assertTSNullKeyword;
    exports.assertTSNumberKeyword = assertTSNumberKeyword;
    exports.assertTSObjectKeyword = assertTSObjectKeyword;
    exports.assertTSOptionalType = assertTSOptionalType;
    exports.assertTSParameterProperty = assertTSParameterProperty;
    exports.assertTSParenthesizedType = assertTSParenthesizedType;
    exports.assertTSPropertySignature = assertTSPropertySignature;
    exports.assertTSQualifiedName = assertTSQualifiedName;
    exports.assertTSRestType = assertTSRestType;
    exports.assertTSSatisfiesExpression = assertTSSatisfiesExpression;
    exports.assertTSStringKeyword = assertTSStringKeyword;
    exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
    exports.assertTSThisType = assertTSThisType;
    exports.assertTSTupleType = assertTSTupleType;
    exports.assertTSType = assertTSType;
    exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
    exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
    exports.assertTSTypeAssertion = assertTSTypeAssertion;
    exports.assertTSTypeElement = assertTSTypeElement;
    exports.assertTSTypeLiteral = assertTSTypeLiteral;
    exports.assertTSTypeOperator = assertTSTypeOperator;
    exports.assertTSTypeParameter = assertTSTypeParameter;
    exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
    exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
    exports.assertTSTypePredicate = assertTSTypePredicate;
    exports.assertTSTypeQuery = assertTSTypeQuery;
    exports.assertTSTypeReference = assertTSTypeReference;
    exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
    exports.assertTSUnionType = assertTSUnionType;
    exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
    exports.assertTSVoidKeyword = assertTSVoidKeyword;
    exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
    exports.assertTemplateElement = assertTemplateElement;
    exports.assertTemplateLiteral = assertTemplateLiteral;
    exports.assertTerminatorless = assertTerminatorless;
    exports.assertThisExpression = assertThisExpression;
    exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
    exports.assertThrowStatement = assertThrowStatement;
    exports.assertTopicReference = assertTopicReference;
    exports.assertTryStatement = assertTryStatement;
    exports.assertTupleExpression = assertTupleExpression;
    exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
    exports.assertTypeAlias = assertTypeAlias;
    exports.assertTypeAnnotation = assertTypeAnnotation;
    exports.assertTypeCastExpression = assertTypeCastExpression;
    exports.assertTypeParameter = assertTypeParameter;
    exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
    exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
    exports.assertTypeScript = assertTypeScript;
    exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
    exports.assertUnaryExpression = assertUnaryExpression;
    exports.assertUnaryLike = assertUnaryLike;
    exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
    exports.assertUpdateExpression = assertUpdateExpression;
    exports.assertUserWhitespacable = assertUserWhitespacable;
    exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
    exports.assertVariableDeclaration = assertVariableDeclaration;
    exports.assertVariableDeclarator = assertVariableDeclarator;
    exports.assertVariance = assertVariance;
    exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
    exports.assertWhile = assertWhile;
    exports.assertWhileStatement = assertWhileStatement;
    exports.assertWithStatement = assertWithStatement;
    exports.assertYieldExpression = assertYieldExpression;
    var _is = require_is();
    var _deprecationWarning = require_deprecationWarning();
    function assert(type, node2, opts) {
      if (!(0, _is.default)(type, node2, opts)) {
        throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, but instead got "${node2.type}".`);
      }
    }
    function assertArrayExpression(node2, opts) {
      assert("ArrayExpression", node2, opts);
    }
    function assertAssignmentExpression(node2, opts) {
      assert("AssignmentExpression", node2, opts);
    }
    function assertBinaryExpression(node2, opts) {
      assert("BinaryExpression", node2, opts);
    }
    function assertInterpreterDirective(node2, opts) {
      assert("InterpreterDirective", node2, opts);
    }
    function assertDirective(node2, opts) {
      assert("Directive", node2, opts);
    }
    function assertDirectiveLiteral(node2, opts) {
      assert("DirectiveLiteral", node2, opts);
    }
    function assertBlockStatement(node2, opts) {
      assert("BlockStatement", node2, opts);
    }
    function assertBreakStatement(node2, opts) {
      assert("BreakStatement", node2, opts);
    }
    function assertCallExpression(node2, opts) {
      assert("CallExpression", node2, opts);
    }
    function assertCatchClause(node2, opts) {
      assert("CatchClause", node2, opts);
    }
    function assertConditionalExpression(node2, opts) {
      assert("ConditionalExpression", node2, opts);
    }
    function assertContinueStatement(node2, opts) {
      assert("ContinueStatement", node2, opts);
    }
    function assertDebuggerStatement(node2, opts) {
      assert("DebuggerStatement", node2, opts);
    }
    function assertDoWhileStatement(node2, opts) {
      assert("DoWhileStatement", node2, opts);
    }
    function assertEmptyStatement(node2, opts) {
      assert("EmptyStatement", node2, opts);
    }
    function assertExpressionStatement(node2, opts) {
      assert("ExpressionStatement", node2, opts);
    }
    function assertFile(node2, opts) {
      assert("File", node2, opts);
    }
    function assertForInStatement(node2, opts) {
      assert("ForInStatement", node2, opts);
    }
    function assertForStatement(node2, opts) {
      assert("ForStatement", node2, opts);
    }
    function assertFunctionDeclaration(node2, opts) {
      assert("FunctionDeclaration", node2, opts);
    }
    function assertFunctionExpression(node2, opts) {
      assert("FunctionExpression", node2, opts);
    }
    function assertIdentifier(node2, opts) {
      assert("Identifier", node2, opts);
    }
    function assertIfStatement(node2, opts) {
      assert("IfStatement", node2, opts);
    }
    function assertLabeledStatement(node2, opts) {
      assert("LabeledStatement", node2, opts);
    }
    function assertStringLiteral(node2, opts) {
      assert("StringLiteral", node2, opts);
    }
    function assertNumericLiteral(node2, opts) {
      assert("NumericLiteral", node2, opts);
    }
    function assertNullLiteral(node2, opts) {
      assert("NullLiteral", node2, opts);
    }
    function assertBooleanLiteral(node2, opts) {
      assert("BooleanLiteral", node2, opts);
    }
    function assertRegExpLiteral(node2, opts) {
      assert("RegExpLiteral", node2, opts);
    }
    function assertLogicalExpression(node2, opts) {
      assert("LogicalExpression", node2, opts);
    }
    function assertMemberExpression(node2, opts) {
      assert("MemberExpression", node2, opts);
    }
    function assertNewExpression(node2, opts) {
      assert("NewExpression", node2, opts);
    }
    function assertProgram(node2, opts) {
      assert("Program", node2, opts);
    }
    function assertObjectExpression(node2, opts) {
      assert("ObjectExpression", node2, opts);
    }
    function assertObjectMethod(node2, opts) {
      assert("ObjectMethod", node2, opts);
    }
    function assertObjectProperty(node2, opts) {
      assert("ObjectProperty", node2, opts);
    }
    function assertRestElement(node2, opts) {
      assert("RestElement", node2, opts);
    }
    function assertReturnStatement(node2, opts) {
      assert("ReturnStatement", node2, opts);
    }
    function assertSequenceExpression(node2, opts) {
      assert("SequenceExpression", node2, opts);
    }
    function assertParenthesizedExpression(node2, opts) {
      assert("ParenthesizedExpression", node2, opts);
    }
    function assertSwitchCase(node2, opts) {
      assert("SwitchCase", node2, opts);
    }
    function assertSwitchStatement(node2, opts) {
      assert("SwitchStatement", node2, opts);
    }
    function assertThisExpression(node2, opts) {
      assert("ThisExpression", node2, opts);
    }
    function assertThrowStatement(node2, opts) {
      assert("ThrowStatement", node2, opts);
    }
    function assertTryStatement(node2, opts) {
      assert("TryStatement", node2, opts);
    }
    function assertUnaryExpression(node2, opts) {
      assert("UnaryExpression", node2, opts);
    }
    function assertUpdateExpression(node2, opts) {
      assert("UpdateExpression", node2, opts);
    }
    function assertVariableDeclaration(node2, opts) {
      assert("VariableDeclaration", node2, opts);
    }
    function assertVariableDeclarator(node2, opts) {
      assert("VariableDeclarator", node2, opts);
    }
    function assertWhileStatement(node2, opts) {
      assert("WhileStatement", node2, opts);
    }
    function assertWithStatement(node2, opts) {
      assert("WithStatement", node2, opts);
    }
    function assertAssignmentPattern(node2, opts) {
      assert("AssignmentPattern", node2, opts);
    }
    function assertArrayPattern(node2, opts) {
      assert("ArrayPattern", node2, opts);
    }
    function assertArrowFunctionExpression(node2, opts) {
      assert("ArrowFunctionExpression", node2, opts);
    }
    function assertClassBody(node2, opts) {
      assert("ClassBody", node2, opts);
    }
    function assertClassExpression(node2, opts) {
      assert("ClassExpression", node2, opts);
    }
    function assertClassDeclaration(node2, opts) {
      assert("ClassDeclaration", node2, opts);
    }
    function assertExportAllDeclaration(node2, opts) {
      assert("ExportAllDeclaration", node2, opts);
    }
    function assertExportDefaultDeclaration(node2, opts) {
      assert("ExportDefaultDeclaration", node2, opts);
    }
    function assertExportNamedDeclaration(node2, opts) {
      assert("ExportNamedDeclaration", node2, opts);
    }
    function assertExportSpecifier(node2, opts) {
      assert("ExportSpecifier", node2, opts);
    }
    function assertForOfStatement(node2, opts) {
      assert("ForOfStatement", node2, opts);
    }
    function assertImportDeclaration(node2, opts) {
      assert("ImportDeclaration", node2, opts);
    }
    function assertImportDefaultSpecifier(node2, opts) {
      assert("ImportDefaultSpecifier", node2, opts);
    }
    function assertImportNamespaceSpecifier(node2, opts) {
      assert("ImportNamespaceSpecifier", node2, opts);
    }
    function assertImportSpecifier(node2, opts) {
      assert("ImportSpecifier", node2, opts);
    }
    function assertMetaProperty(node2, opts) {
      assert("MetaProperty", node2, opts);
    }
    function assertClassMethod(node2, opts) {
      assert("ClassMethod", node2, opts);
    }
    function assertObjectPattern(node2, opts) {
      assert("ObjectPattern", node2, opts);
    }
    function assertSpreadElement(node2, opts) {
      assert("SpreadElement", node2, opts);
    }
    function assertSuper(node2, opts) {
      assert("Super", node2, opts);
    }
    function assertTaggedTemplateExpression(node2, opts) {
      assert("TaggedTemplateExpression", node2, opts);
    }
    function assertTemplateElement(node2, opts) {
      assert("TemplateElement", node2, opts);
    }
    function assertTemplateLiteral(node2, opts) {
      assert("TemplateLiteral", node2, opts);
    }
    function assertYieldExpression(node2, opts) {
      assert("YieldExpression", node2, opts);
    }
    function assertAwaitExpression(node2, opts) {
      assert("AwaitExpression", node2, opts);
    }
    function assertImport(node2, opts) {
      assert("Import", node2, opts);
    }
    function assertBigIntLiteral(node2, opts) {
      assert("BigIntLiteral", node2, opts);
    }
    function assertExportNamespaceSpecifier(node2, opts) {
      assert("ExportNamespaceSpecifier", node2, opts);
    }
    function assertOptionalMemberExpression(node2, opts) {
      assert("OptionalMemberExpression", node2, opts);
    }
    function assertOptionalCallExpression(node2, opts) {
      assert("OptionalCallExpression", node2, opts);
    }
    function assertClassProperty(node2, opts) {
      assert("ClassProperty", node2, opts);
    }
    function assertClassAccessorProperty(node2, opts) {
      assert("ClassAccessorProperty", node2, opts);
    }
    function assertClassPrivateProperty(node2, opts) {
      assert("ClassPrivateProperty", node2, opts);
    }
    function assertClassPrivateMethod(node2, opts) {
      assert("ClassPrivateMethod", node2, opts);
    }
    function assertPrivateName(node2, opts) {
      assert("PrivateName", node2, opts);
    }
    function assertStaticBlock(node2, opts) {
      assert("StaticBlock", node2, opts);
    }
    function assertAnyTypeAnnotation(node2, opts) {
      assert("AnyTypeAnnotation", node2, opts);
    }
    function assertArrayTypeAnnotation(node2, opts) {
      assert("ArrayTypeAnnotation", node2, opts);
    }
    function assertBooleanTypeAnnotation(node2, opts) {
      assert("BooleanTypeAnnotation", node2, opts);
    }
    function assertBooleanLiteralTypeAnnotation(node2, opts) {
      assert("BooleanLiteralTypeAnnotation", node2, opts);
    }
    function assertNullLiteralTypeAnnotation(node2, opts) {
      assert("NullLiteralTypeAnnotation", node2, opts);
    }
    function assertClassImplements(node2, opts) {
      assert("ClassImplements", node2, opts);
    }
    function assertDeclareClass(node2, opts) {
      assert("DeclareClass", node2, opts);
    }
    function assertDeclareFunction(node2, opts) {
      assert("DeclareFunction", node2, opts);
    }
    function assertDeclareInterface(node2, opts) {
      assert("DeclareInterface", node2, opts);
    }
    function assertDeclareModule(node2, opts) {
      assert("DeclareModule", node2, opts);
    }
    function assertDeclareModuleExports(node2, opts) {
      assert("DeclareModuleExports", node2, opts);
    }
    function assertDeclareTypeAlias(node2, opts) {
      assert("DeclareTypeAlias", node2, opts);
    }
    function assertDeclareOpaqueType(node2, opts) {
      assert("DeclareOpaqueType", node2, opts);
    }
    function assertDeclareVariable(node2, opts) {
      assert("DeclareVariable", node2, opts);
    }
    function assertDeclareExportDeclaration(node2, opts) {
      assert("DeclareExportDeclaration", node2, opts);
    }
    function assertDeclareExportAllDeclaration(node2, opts) {
      assert("DeclareExportAllDeclaration", node2, opts);
    }
    function assertDeclaredPredicate(node2, opts) {
      assert("DeclaredPredicate", node2, opts);
    }
    function assertExistsTypeAnnotation(node2, opts) {
      assert("ExistsTypeAnnotation", node2, opts);
    }
    function assertFunctionTypeAnnotation(node2, opts) {
      assert("FunctionTypeAnnotation", node2, opts);
    }
    function assertFunctionTypeParam(node2, opts) {
      assert("FunctionTypeParam", node2, opts);
    }
    function assertGenericTypeAnnotation(node2, opts) {
      assert("GenericTypeAnnotation", node2, opts);
    }
    function assertInferredPredicate(node2, opts) {
      assert("InferredPredicate", node2, opts);
    }
    function assertInterfaceExtends(node2, opts) {
      assert("InterfaceExtends", node2, opts);
    }
    function assertInterfaceDeclaration(node2, opts) {
      assert("InterfaceDeclaration", node2, opts);
    }
    function assertInterfaceTypeAnnotation(node2, opts) {
      assert("InterfaceTypeAnnotation", node2, opts);
    }
    function assertIntersectionTypeAnnotation(node2, opts) {
      assert("IntersectionTypeAnnotation", node2, opts);
    }
    function assertMixedTypeAnnotation(node2, opts) {
      assert("MixedTypeAnnotation", node2, opts);
    }
    function assertEmptyTypeAnnotation(node2, opts) {
      assert("EmptyTypeAnnotation", node2, opts);
    }
    function assertNullableTypeAnnotation(node2, opts) {
      assert("NullableTypeAnnotation", node2, opts);
    }
    function assertNumberLiteralTypeAnnotation(node2, opts) {
      assert("NumberLiteralTypeAnnotation", node2, opts);
    }
    function assertNumberTypeAnnotation(node2, opts) {
      assert("NumberTypeAnnotation", node2, opts);
    }
    function assertObjectTypeAnnotation(node2, opts) {
      assert("ObjectTypeAnnotation", node2, opts);
    }
    function assertObjectTypeInternalSlot(node2, opts) {
      assert("ObjectTypeInternalSlot", node2, opts);
    }
    function assertObjectTypeCallProperty(node2, opts) {
      assert("ObjectTypeCallProperty", node2, opts);
    }
    function assertObjectTypeIndexer(node2, opts) {
      assert("ObjectTypeIndexer", node2, opts);
    }
    function assertObjectTypeProperty(node2, opts) {
      assert("ObjectTypeProperty", node2, opts);
    }
    function assertObjectTypeSpreadProperty(node2, opts) {
      assert("ObjectTypeSpreadProperty", node2, opts);
    }
    function assertOpaqueType(node2, opts) {
      assert("OpaqueType", node2, opts);
    }
    function assertQualifiedTypeIdentifier(node2, opts) {
      assert("QualifiedTypeIdentifier", node2, opts);
    }
    function assertStringLiteralTypeAnnotation(node2, opts) {
      assert("StringLiteralTypeAnnotation", node2, opts);
    }
    function assertStringTypeAnnotation(node2, opts) {
      assert("StringTypeAnnotation", node2, opts);
    }
    function assertSymbolTypeAnnotation(node2, opts) {
      assert("SymbolTypeAnnotation", node2, opts);
    }
    function assertThisTypeAnnotation(node2, opts) {
      assert("ThisTypeAnnotation", node2, opts);
    }
    function assertTupleTypeAnnotation(node2, opts) {
      assert("TupleTypeAnnotation", node2, opts);
    }
    function assertTypeofTypeAnnotation(node2, opts) {
      assert("TypeofTypeAnnotation", node2, opts);
    }
    function assertTypeAlias(node2, opts) {
      assert("TypeAlias", node2, opts);
    }
    function assertTypeAnnotation(node2, opts) {
      assert("TypeAnnotation", node2, opts);
    }
    function assertTypeCastExpression(node2, opts) {
      assert("TypeCastExpression", node2, opts);
    }
    function assertTypeParameter(node2, opts) {
      assert("TypeParameter", node2, opts);
    }
    function assertTypeParameterDeclaration(node2, opts) {
      assert("TypeParameterDeclaration", node2, opts);
    }
    function assertTypeParameterInstantiation(node2, opts) {
      assert("TypeParameterInstantiation", node2, opts);
    }
    function assertUnionTypeAnnotation(node2, opts) {
      assert("UnionTypeAnnotation", node2, opts);
    }
    function assertVariance(node2, opts) {
      assert("Variance", node2, opts);
    }
    function assertVoidTypeAnnotation(node2, opts) {
      assert("VoidTypeAnnotation", node2, opts);
    }
    function assertEnumDeclaration(node2, opts) {
      assert("EnumDeclaration", node2, opts);
    }
    function assertEnumBooleanBody(node2, opts) {
      assert("EnumBooleanBody", node2, opts);
    }
    function assertEnumNumberBody(node2, opts) {
      assert("EnumNumberBody", node2, opts);
    }
    function assertEnumStringBody(node2, opts) {
      assert("EnumStringBody", node2, opts);
    }
    function assertEnumSymbolBody(node2, opts) {
      assert("EnumSymbolBody", node2, opts);
    }
    function assertEnumBooleanMember(node2, opts) {
      assert("EnumBooleanMember", node2, opts);
    }
    function assertEnumNumberMember(node2, opts) {
      assert("EnumNumberMember", node2, opts);
    }
    function assertEnumStringMember(node2, opts) {
      assert("EnumStringMember", node2, opts);
    }
    function assertEnumDefaultedMember(node2, opts) {
      assert("EnumDefaultedMember", node2, opts);
    }
    function assertIndexedAccessType(node2, opts) {
      assert("IndexedAccessType", node2, opts);
    }
    function assertOptionalIndexedAccessType(node2, opts) {
      assert("OptionalIndexedAccessType", node2, opts);
    }
    function assertJSXAttribute(node2, opts) {
      assert("JSXAttribute", node2, opts);
    }
    function assertJSXClosingElement(node2, opts) {
      assert("JSXClosingElement", node2, opts);
    }
    function assertJSXElement(node2, opts) {
      assert("JSXElement", node2, opts);
    }
    function assertJSXEmptyExpression(node2, opts) {
      assert("JSXEmptyExpression", node2, opts);
    }
    function assertJSXExpressionContainer(node2, opts) {
      assert("JSXExpressionContainer", node2, opts);
    }
    function assertJSXSpreadChild(node2, opts) {
      assert("JSXSpreadChild", node2, opts);
    }
    function assertJSXIdentifier(node2, opts) {
      assert("JSXIdentifier", node2, opts);
    }
    function assertJSXMemberExpression(node2, opts) {
      assert("JSXMemberExpression", node2, opts);
    }
    function assertJSXNamespacedName(node2, opts) {
      assert("JSXNamespacedName", node2, opts);
    }
    function assertJSXOpeningElement(node2, opts) {
      assert("JSXOpeningElement", node2, opts);
    }
    function assertJSXSpreadAttribute(node2, opts) {
      assert("JSXSpreadAttribute", node2, opts);
    }
    function assertJSXText(node2, opts) {
      assert("JSXText", node2, opts);
    }
    function assertJSXFragment(node2, opts) {
      assert("JSXFragment", node2, opts);
    }
    function assertJSXOpeningFragment(node2, opts) {
      assert("JSXOpeningFragment", node2, opts);
    }
    function assertJSXClosingFragment(node2, opts) {
      assert("JSXClosingFragment", node2, opts);
    }
    function assertNoop(node2, opts) {
      assert("Noop", node2, opts);
    }
    function assertPlaceholder(node2, opts) {
      assert("Placeholder", node2, opts);
    }
    function assertV8IntrinsicIdentifier(node2, opts) {
      assert("V8IntrinsicIdentifier", node2, opts);
    }
    function assertArgumentPlaceholder(node2, opts) {
      assert("ArgumentPlaceholder", node2, opts);
    }
    function assertBindExpression(node2, opts) {
      assert("BindExpression", node2, opts);
    }
    function assertImportAttribute(node2, opts) {
      assert("ImportAttribute", node2, opts);
    }
    function assertDecorator(node2, opts) {
      assert("Decorator", node2, opts);
    }
    function assertDoExpression(node2, opts) {
      assert("DoExpression", node2, opts);
    }
    function assertExportDefaultSpecifier(node2, opts) {
      assert("ExportDefaultSpecifier", node2, opts);
    }
    function assertRecordExpression(node2, opts) {
      assert("RecordExpression", node2, opts);
    }
    function assertTupleExpression(node2, opts) {
      assert("TupleExpression", node2, opts);
    }
    function assertDecimalLiteral(node2, opts) {
      assert("DecimalLiteral", node2, opts);
    }
    function assertModuleExpression(node2, opts) {
      assert("ModuleExpression", node2, opts);
    }
    function assertTopicReference(node2, opts) {
      assert("TopicReference", node2, opts);
    }
    function assertPipelineTopicExpression(node2, opts) {
      assert("PipelineTopicExpression", node2, opts);
    }
    function assertPipelineBareFunction(node2, opts) {
      assert("PipelineBareFunction", node2, opts);
    }
    function assertPipelinePrimaryTopicReference(node2, opts) {
      assert("PipelinePrimaryTopicReference", node2, opts);
    }
    function assertTSParameterProperty(node2, opts) {
      assert("TSParameterProperty", node2, opts);
    }
    function assertTSDeclareFunction(node2, opts) {
      assert("TSDeclareFunction", node2, opts);
    }
    function assertTSDeclareMethod(node2, opts) {
      assert("TSDeclareMethod", node2, opts);
    }
    function assertTSQualifiedName(node2, opts) {
      assert("TSQualifiedName", node2, opts);
    }
    function assertTSCallSignatureDeclaration(node2, opts) {
      assert("TSCallSignatureDeclaration", node2, opts);
    }
    function assertTSConstructSignatureDeclaration(node2, opts) {
      assert("TSConstructSignatureDeclaration", node2, opts);
    }
    function assertTSPropertySignature(node2, opts) {
      assert("TSPropertySignature", node2, opts);
    }
    function assertTSMethodSignature(node2, opts) {
      assert("TSMethodSignature", node2, opts);
    }
    function assertTSIndexSignature(node2, opts) {
      assert("TSIndexSignature", node2, opts);
    }
    function assertTSAnyKeyword(node2, opts) {
      assert("TSAnyKeyword", node2, opts);
    }
    function assertTSBooleanKeyword(node2, opts) {
      assert("TSBooleanKeyword", node2, opts);
    }
    function assertTSBigIntKeyword(node2, opts) {
      assert("TSBigIntKeyword", node2, opts);
    }
    function assertTSIntrinsicKeyword(node2, opts) {
      assert("TSIntrinsicKeyword", node2, opts);
    }
    function assertTSNeverKeyword(node2, opts) {
      assert("TSNeverKeyword", node2, opts);
    }
    function assertTSNullKeyword(node2, opts) {
      assert("TSNullKeyword", node2, opts);
    }
    function assertTSNumberKeyword(node2, opts) {
      assert("TSNumberKeyword", node2, opts);
    }
    function assertTSObjectKeyword(node2, opts) {
      assert("TSObjectKeyword", node2, opts);
    }
    function assertTSStringKeyword(node2, opts) {
      assert("TSStringKeyword", node2, opts);
    }
    function assertTSSymbolKeyword(node2, opts) {
      assert("TSSymbolKeyword", node2, opts);
    }
    function assertTSUndefinedKeyword(node2, opts) {
      assert("TSUndefinedKeyword", node2, opts);
    }
    function assertTSUnknownKeyword(node2, opts) {
      assert("TSUnknownKeyword", node2, opts);
    }
    function assertTSVoidKeyword(node2, opts) {
      assert("TSVoidKeyword", node2, opts);
    }
    function assertTSThisType(node2, opts) {
      assert("TSThisType", node2, opts);
    }
    function assertTSFunctionType(node2, opts) {
      assert("TSFunctionType", node2, opts);
    }
    function assertTSConstructorType(node2, opts) {
      assert("TSConstructorType", node2, opts);
    }
    function assertTSTypeReference(node2, opts) {
      assert("TSTypeReference", node2, opts);
    }
    function assertTSTypePredicate(node2, opts) {
      assert("TSTypePredicate", node2, opts);
    }
    function assertTSTypeQuery(node2, opts) {
      assert("TSTypeQuery", node2, opts);
    }
    function assertTSTypeLiteral(node2, opts) {
      assert("TSTypeLiteral", node2, opts);
    }
    function assertTSArrayType(node2, opts) {
      assert("TSArrayType", node2, opts);
    }
    function assertTSTupleType(node2, opts) {
      assert("TSTupleType", node2, opts);
    }
    function assertTSOptionalType(node2, opts) {
      assert("TSOptionalType", node2, opts);
    }
    function assertTSRestType(node2, opts) {
      assert("TSRestType", node2, opts);
    }
    function assertTSNamedTupleMember(node2, opts) {
      assert("TSNamedTupleMember", node2, opts);
    }
    function assertTSUnionType(node2, opts) {
      assert("TSUnionType", node2, opts);
    }
    function assertTSIntersectionType(node2, opts) {
      assert("TSIntersectionType", node2, opts);
    }
    function assertTSConditionalType(node2, opts) {
      assert("TSConditionalType", node2, opts);
    }
    function assertTSInferType(node2, opts) {
      assert("TSInferType", node2, opts);
    }
    function assertTSParenthesizedType(node2, opts) {
      assert("TSParenthesizedType", node2, opts);
    }
    function assertTSTypeOperator(node2, opts) {
      assert("TSTypeOperator", node2, opts);
    }
    function assertTSIndexedAccessType(node2, opts) {
      assert("TSIndexedAccessType", node2, opts);
    }
    function assertTSMappedType(node2, opts) {
      assert("TSMappedType", node2, opts);
    }
    function assertTSLiteralType(node2, opts) {
      assert("TSLiteralType", node2, opts);
    }
    function assertTSExpressionWithTypeArguments(node2, opts) {
      assert("TSExpressionWithTypeArguments", node2, opts);
    }
    function assertTSInterfaceDeclaration(node2, opts) {
      assert("TSInterfaceDeclaration", node2, opts);
    }
    function assertTSInterfaceBody(node2, opts) {
      assert("TSInterfaceBody", node2, opts);
    }
    function assertTSTypeAliasDeclaration(node2, opts) {
      assert("TSTypeAliasDeclaration", node2, opts);
    }
    function assertTSInstantiationExpression(node2, opts) {
      assert("TSInstantiationExpression", node2, opts);
    }
    function assertTSAsExpression(node2, opts) {
      assert("TSAsExpression", node2, opts);
    }
    function assertTSSatisfiesExpression(node2, opts) {
      assert("TSSatisfiesExpression", node2, opts);
    }
    function assertTSTypeAssertion(node2, opts) {
      assert("TSTypeAssertion", node2, opts);
    }
    function assertTSEnumDeclaration(node2, opts) {
      assert("TSEnumDeclaration", node2, opts);
    }
    function assertTSEnumMember(node2, opts) {
      assert("TSEnumMember", node2, opts);
    }
    function assertTSModuleDeclaration(node2, opts) {
      assert("TSModuleDeclaration", node2, opts);
    }
    function assertTSModuleBlock(node2, opts) {
      assert("TSModuleBlock", node2, opts);
    }
    function assertTSImportType(node2, opts) {
      assert("TSImportType", node2, opts);
    }
    function assertTSImportEqualsDeclaration(node2, opts) {
      assert("TSImportEqualsDeclaration", node2, opts);
    }
    function assertTSExternalModuleReference(node2, opts) {
      assert("TSExternalModuleReference", node2, opts);
    }
    function assertTSNonNullExpression(node2, opts) {
      assert("TSNonNullExpression", node2, opts);
    }
    function assertTSExportAssignment(node2, opts) {
      assert("TSExportAssignment", node2, opts);
    }
    function assertTSNamespaceExportDeclaration(node2, opts) {
      assert("TSNamespaceExportDeclaration", node2, opts);
    }
    function assertTSTypeAnnotation(node2, opts) {
      assert("TSTypeAnnotation", node2, opts);
    }
    function assertTSTypeParameterInstantiation(node2, opts) {
      assert("TSTypeParameterInstantiation", node2, opts);
    }
    function assertTSTypeParameterDeclaration(node2, opts) {
      assert("TSTypeParameterDeclaration", node2, opts);
    }
    function assertTSTypeParameter(node2, opts) {
      assert("TSTypeParameter", node2, opts);
    }
    function assertStandardized(node2, opts) {
      assert("Standardized", node2, opts);
    }
    function assertExpression(node2, opts) {
      assert("Expression", node2, opts);
    }
    function assertBinary(node2, opts) {
      assert("Binary", node2, opts);
    }
    function assertScopable(node2, opts) {
      assert("Scopable", node2, opts);
    }
    function assertBlockParent(node2, opts) {
      assert("BlockParent", node2, opts);
    }
    function assertBlock(node2, opts) {
      assert("Block", node2, opts);
    }
    function assertStatement(node2, opts) {
      assert("Statement", node2, opts);
    }
    function assertTerminatorless(node2, opts) {
      assert("Terminatorless", node2, opts);
    }
    function assertCompletionStatement(node2, opts) {
      assert("CompletionStatement", node2, opts);
    }
    function assertConditional(node2, opts) {
      assert("Conditional", node2, opts);
    }
    function assertLoop(node2, opts) {
      assert("Loop", node2, opts);
    }
    function assertWhile(node2, opts) {
      assert("While", node2, opts);
    }
    function assertExpressionWrapper(node2, opts) {
      assert("ExpressionWrapper", node2, opts);
    }
    function assertFor(node2, opts) {
      assert("For", node2, opts);
    }
    function assertForXStatement(node2, opts) {
      assert("ForXStatement", node2, opts);
    }
    function assertFunction(node2, opts) {
      assert("Function", node2, opts);
    }
    function assertFunctionParent(node2, opts) {
      assert("FunctionParent", node2, opts);
    }
    function assertPureish(node2, opts) {
      assert("Pureish", node2, opts);
    }
    function assertDeclaration(node2, opts) {
      assert("Declaration", node2, opts);
    }
    function assertPatternLike(node2, opts) {
      assert("PatternLike", node2, opts);
    }
    function assertLVal(node2, opts) {
      assert("LVal", node2, opts);
    }
    function assertTSEntityName(node2, opts) {
      assert("TSEntityName", node2, opts);
    }
    function assertLiteral(node2, opts) {
      assert("Literal", node2, opts);
    }
    function assertImmutable(node2, opts) {
      assert("Immutable", node2, opts);
    }
    function assertUserWhitespacable(node2, opts) {
      assert("UserWhitespacable", node2, opts);
    }
    function assertMethod(node2, opts) {
      assert("Method", node2, opts);
    }
    function assertObjectMember(node2, opts) {
      assert("ObjectMember", node2, opts);
    }
    function assertProperty(node2, opts) {
      assert("Property", node2, opts);
    }
    function assertUnaryLike(node2, opts) {
      assert("UnaryLike", node2, opts);
    }
    function assertPattern(node2, opts) {
      assert("Pattern", node2, opts);
    }
    function assertClass(node2, opts) {
      assert("Class", node2, opts);
    }
    function assertImportOrExportDeclaration(node2, opts) {
      assert("ImportOrExportDeclaration", node2, opts);
    }
    function assertExportDeclaration(node2, opts) {
      assert("ExportDeclaration", node2, opts);
    }
    function assertModuleSpecifier(node2, opts) {
      assert("ModuleSpecifier", node2, opts);
    }
    function assertAccessor(node2, opts) {
      assert("Accessor", node2, opts);
    }
    function assertPrivate(node2, opts) {
      assert("Private", node2, opts);
    }
    function assertFlow(node2, opts) {
      assert("Flow", node2, opts);
    }
    function assertFlowType(node2, opts) {
      assert("FlowType", node2, opts);
    }
    function assertFlowBaseAnnotation(node2, opts) {
      assert("FlowBaseAnnotation", node2, opts);
    }
    function assertFlowDeclaration(node2, opts) {
      assert("FlowDeclaration", node2, opts);
    }
    function assertFlowPredicate(node2, opts) {
      assert("FlowPredicate", node2, opts);
    }
    function assertEnumBody(node2, opts) {
      assert("EnumBody", node2, opts);
    }
    function assertEnumMember(node2, opts) {
      assert("EnumMember", node2, opts);
    }
    function assertJSX(node2, opts) {
      assert("JSX", node2, opts);
    }
    function assertMiscellaneous(node2, opts) {
      assert("Miscellaneous", node2, opts);
    }
    function assertTypeScript(node2, opts) {
      assert("TypeScript", node2, opts);
    }
    function assertTSTypeElement(node2, opts) {
      assert("TSTypeElement", node2, opts);
    }
    function assertTSType(node2, opts) {
      assert("TSType", node2, opts);
    }
    function assertTSBaseType(node2, opts) {
      assert("TSBaseType", node2, opts);
    }
    function assertNumberLiteral(node2, opts) {
      (0, _deprecationWarning.default)("assertNumberLiteral", "assertNumericLiteral");
      assert("NumberLiteral", node2, opts);
    }
    function assertRegexLiteral(node2, opts) {
      (0, _deprecationWarning.default)("assertRegexLiteral", "assertRegExpLiteral");
      assert("RegexLiteral", node2, opts);
    }
    function assertRestProperty(node2, opts) {
      (0, _deprecationWarning.default)("assertRestProperty", "assertRestElement");
      assert("RestProperty", node2, opts);
    }
    function assertSpreadProperty(node2, opts) {
      (0, _deprecationWarning.default)("assertSpreadProperty", "assertSpreadElement");
      assert("SpreadProperty", node2, opts);
    }
    function assertModuleDeclaration(node2, opts) {
      (0, _deprecationWarning.default)("assertModuleDeclaration", "assertImportOrExportDeclaration");
      assert("ModuleDeclaration", node2, opts);
    }
  }
});

// node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
var require_createTypeAnnotationBasedOnTypeof = __commonJS({
  "node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _generated = require_generated2();
    var _default = createTypeAnnotationBasedOnTypeof;
    exports.default = _default;
    function createTypeAnnotationBasedOnTypeof(type) {
      switch (type) {
        case "string":
          return (0, _generated.stringTypeAnnotation)();
        case "number":
          return (0, _generated.numberTypeAnnotation)();
        case "undefined":
          return (0, _generated.voidTypeAnnotation)();
        case "boolean":
          return (0, _generated.booleanTypeAnnotation)();
        case "function":
          return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
        case "object":
          return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
        case "symbol":
          return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
        case "bigint":
          return (0, _generated.anyTypeAnnotation)();
      }
      throw new Error("Invalid typeof value: " + type);
    }
  }
});

// node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
var require_removeTypeDuplicates = __commonJS({
  "node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = removeTypeDuplicates;
    var _generated = require_generated();
    function getQualifiedName(node2) {
      return (0, _generated.isIdentifier)(node2) ? node2.name : `${node2.id.name}.${getQualifiedName(node2.qualification)}`;
    }
    function removeTypeDuplicates(nodes) {
      const generics = /* @__PURE__ */ new Map();
      const bases = /* @__PURE__ */ new Map();
      const typeGroups = /* @__PURE__ */ new Set();
      const types3 = [];
      for (let i = 0; i < nodes.length; i++) {
        const node2 = nodes[i];
        if (!node2)
          continue;
        if (types3.indexOf(node2) >= 0) {
          continue;
        }
        if ((0, _generated.isAnyTypeAnnotation)(node2)) {
          return [node2];
        }
        if ((0, _generated.isFlowBaseAnnotation)(node2)) {
          bases.set(node2.type, node2);
          continue;
        }
        if ((0, _generated.isUnionTypeAnnotation)(node2)) {
          if (!typeGroups.has(node2.types)) {
            nodes = nodes.concat(node2.types);
            typeGroups.add(node2.types);
          }
          continue;
        }
        if ((0, _generated.isGenericTypeAnnotation)(node2)) {
          const name2 = getQualifiedName(node2.id);
          if (generics.has(name2)) {
            let existing = generics.get(name2);
            if (existing.typeParameters) {
              if (node2.typeParameters) {
                existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node2.typeParameters.params));
              }
            } else {
              existing = node2.typeParameters;
            }
          } else {
            generics.set(name2, node2);
          }
          continue;
        }
        types3.push(node2);
      }
      for (const [, baseType] of bases) {
        types3.push(baseType);
      }
      for (const [, genericName] of generics) {
        types3.push(genericName);
      }
      return types3;
    }
  }
});

// node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
var require_createFlowUnionType = __commonJS({
  "node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = createFlowUnionType;
    var _generated = require_generated2();
    var _removeTypeDuplicates = require_removeTypeDuplicates();
    function createFlowUnionType(types3) {
      const flattened = (0, _removeTypeDuplicates.default)(types3);
      if (flattened.length === 1) {
        return flattened[0];
      } else {
        return (0, _generated.unionTypeAnnotation)(flattened);
      }
    }
  }
});

// node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js
var require_removeTypeDuplicates2 = __commonJS({
  "node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = removeTypeDuplicates;
    var _generated = require_generated();
    function getQualifiedName(node2) {
      return (0, _generated.isIdentifier)(node2) ? node2.name : `${node2.right.name}.${getQualifiedName(node2.left)}`;
    }
    function removeTypeDuplicates(nodes) {
      const generics = /* @__PURE__ */ new Map();
      const bases = /* @__PURE__ */ new Map();
      const typeGroups = /* @__PURE__ */ new Set();
      const types3 = [];
      for (let i = 0; i < nodes.length; i++) {
        const node2 = nodes[i];
        if (!node2)
          continue;
        if (types3.indexOf(node2) >= 0) {
          continue;
        }
        if ((0, _generated.isTSAnyKeyword)(node2)) {
          return [node2];
        }
        if ((0, _generated.isTSBaseType)(node2)) {
          bases.set(node2.type, node2);
          continue;
        }
        if ((0, _generated.isTSUnionType)(node2)) {
          if (!typeGroups.has(node2.types)) {
            nodes.push(...node2.types);
            typeGroups.add(node2.types);
          }
          continue;
        }
        if ((0, _generated.isTSTypeReference)(node2) && node2.typeParameters) {
          const name2 = getQualifiedName(node2.typeName);
          if (generics.has(name2)) {
            let existing = generics.get(name2);
            if (existing.typeParameters) {
              if (node2.typeParameters) {
                existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node2.typeParameters.params));
              }
            } else {
              existing = node2.typeParameters;
            }
          } else {
            generics.set(name2, node2);
          }
          continue;
        }
        types3.push(node2);
      }
      for (const [, baseType] of bases) {
        types3.push(baseType);
      }
      for (const [, genericName] of generics) {
        types3.push(genericName);
      }
      return types3;
    }
  }
});

// node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
var require_createTSUnionType = __commonJS({
  "node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = createTSUnionType;
    var _generated = require_generated2();
    var _removeTypeDuplicates = require_removeTypeDuplicates2();
    var _index = require_generated();
    function createTSUnionType(typeAnnotations) {
      const types3 = typeAnnotations.map((type) => {
        return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
      });
      const flattened = (0, _removeTypeDuplicates.default)(types3);
      if (flattened.length === 1) {
        return flattened[0];
      } else {
        return (0, _generated.tsUnionType)(flattened);
      }
    }
  }
});

// node_modules/@babel/types/lib/builders/generated/uppercase.js
var require_uppercase = __commonJS({
  "node_modules/@babel/types/lib/builders/generated/uppercase.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "AnyTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.anyTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "ArgumentPlaceholder", {
      enumerable: true,
      get: function() {
        return _index.argumentPlaceholder;
      }
    });
    Object.defineProperty(exports, "ArrayExpression", {
      enumerable: true,
      get: function() {
        return _index.arrayExpression;
      }
    });
    Object.defineProperty(exports, "ArrayPattern", {
      enumerable: true,
      get: function() {
        return _index.arrayPattern;
      }
    });
    Object.defineProperty(exports, "ArrayTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.arrayTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "ArrowFunctionExpression", {
      enumerable: true,
      get: function() {
        return _index.arrowFunctionExpression;
      }
    });
    Object.defineProperty(exports, "AssignmentExpression", {
      enumerable: true,
      get: function() {
        return _index.assignmentExpression;
      }
    });
    Object.defineProperty(exports, "AssignmentPattern", {
      enumerable: true,
      get: function() {
        return _index.assignmentPattern;
      }
    });
    Object.defineProperty(exports, "AwaitExpression", {
      enumerable: true,
      get: function() {
        return _index.awaitExpression;
      }
    });
    Object.defineProperty(exports, "BigIntLiteral", {
      enumerable: true,
      get: function() {
        return _index.bigIntLiteral;
      }
    });
    Object.defineProperty(exports, "BinaryExpression", {
      enumerable: true,
      get: function() {
        return _index.binaryExpression;
      }
    });
    Object.defineProperty(exports, "BindExpression", {
      enumerable: true,
      get: function() {
        return _index.bindExpression;
      }
    });
    Object.defineProperty(exports, "BlockStatement", {
      enumerable: true,
      get: function() {
        return _index.blockStatement;
      }
    });
    Object.defineProperty(exports, "BooleanLiteral", {
      enumerable: true,
      get: function() {
        return _index.booleanLiteral;
      }
    });
    Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.booleanLiteralTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "BooleanTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.booleanTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "BreakStatement", {
      enumerable: true,
      get: function() {
        return _index.breakStatement;
      }
    });
    Object.defineProperty(exports, "CallExpression", {
      enumerable: true,
      get: function() {
        return _index.callExpression;
      }
    });
    Object.defineProperty(exports, "CatchClause", {
      enumerable: true,
      get: function() {
        return _index.catchClause;
      }
    });
    Object.defineProperty(exports, "ClassAccessorProperty", {
      enumerable: true,
      get: function() {
        return _index.classAccessorProperty;
      }
    });
    Object.defineProperty(exports, "ClassBody", {
      enumerable: true,
      get: function() {
        return _index.classBody;
      }
    });
    Object.defineProperty(exports, "ClassDeclaration", {
      enumerable: true,
      get: function() {
        return _index.classDeclaration;
      }
    });
    Object.defineProperty(exports, "ClassExpression", {
      enumerable: true,
      get: function() {
        return _index.classExpression;
      }
    });
    Object.defineProperty(exports, "ClassImplements", {
      enumerable: true,
      get: function() {
        return _index.classImplements;
      }
    });
    Object.defineProperty(exports, "ClassMethod", {
      enumerable: true,
      get: function() {
        return _index.classMethod;
      }
    });
    Object.defineProperty(exports, "ClassPrivateMethod", {
      enumerable: true,
      get: function() {
        return _index.classPrivateMethod;
      }
    });
    Object.defineProperty(exports, "ClassPrivateProperty", {
      enumerable: true,
      get: function() {
        return _index.classPrivateProperty;
      }
    });
    Object.defineProperty(exports, "ClassProperty", {
      enumerable: true,
      get: function() {
        return _index.classProperty;
      }
    });
    Object.defineProperty(exports, "ConditionalExpression", {
      enumerable: true,
      get: function() {
        return _index.conditionalExpression;
      }
    });
    Object.defineProperty(exports, "ContinueStatement", {
      enumerable: true,
      get: function() {
        return _index.continueStatement;
      }
    });
    Object.defineProperty(exports, "DebuggerStatement", {
      enumerable: true,
      get: function() {
        return _index.debuggerStatement;
      }
    });
    Object.defineProperty(exports, "DecimalLiteral", {
      enumerable: true,
      get: function() {
        return _index.decimalLiteral;
      }
    });
    Object.defineProperty(exports, "DeclareClass", {
      enumerable: true,
      get: function() {
        return _index.declareClass;
      }
    });
    Object.defineProperty(exports, "DeclareExportAllDeclaration", {
      enumerable: true,
      get: function() {
        return _index.declareExportAllDeclaration;
      }
    });
    Object.defineProperty(exports, "DeclareExportDeclaration", {
      enumerable: true,
      get: function() {
        return _index.declareExportDeclaration;
      }
    });
    Object.defineProperty(exports, "DeclareFunction", {
      enumerable: true,
      get: function() {
        return _index.declareFunction;
      }
    });
    Object.defineProperty(exports, "DeclareInterface", {
      enumerable: true,
      get: function() {
        return _index.declareInterface;
      }
    });
    Object.defineProperty(exports, "DeclareModule", {
      enumerable: true,
      get: function() {
        return _index.declareModule;
      }
    });
    Object.defineProperty(exports, "DeclareModuleExports", {
      enumerable: true,
      get: function() {
        return _index.declareModuleExports;
      }
    });
    Object.defineProperty(exports, "DeclareOpaqueType", {
      enumerable: true,
      get: function() {
        return _index.declareOpaqueType;
      }
    });
    Object.defineProperty(exports, "DeclareTypeAlias", {
      enumerable: true,
      get: function() {
        return _index.declareTypeAlias;
      }
    });
    Object.defineProperty(exports, "DeclareVariable", {
      enumerable: true,
      get: function() {
        return _index.declareVariable;
      }
    });
    Object.defineProperty(exports, "DeclaredPredicate", {
      enumerable: true,
      get: function() {
        return _index.declaredPredicate;
      }
    });
    Object.defineProperty(exports, "Decorator", {
      enumerable: true,
      get: function() {
        return _index.decorator;
      }
    });
    Object.defineProperty(exports, "Directive", {
      enumerable: true,
      get: function() {
        return _index.directive;
      }
    });
    Object.defineProperty(exports, "DirectiveLiteral", {
      enumerable: true,
      get: function() {
        return _index.directiveLiteral;
      }
    });
    Object.defineProperty(exports, "DoExpression", {
      enumerable: true,
      get: function() {
        return _index.doExpression;
      }
    });
    Object.defineProperty(exports, "DoWhileStatement", {
      enumerable: true,
      get: function() {
        return _index.doWhileStatement;
      }
    });
    Object.defineProperty(exports, "EmptyStatement", {
      enumerable: true,
      get: function() {
        return _index.emptyStatement;
      }
    });
    Object.defineProperty(exports, "EmptyTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.emptyTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "EnumBooleanBody", {
      enumerable: true,
      get: function() {
        return _index.enumBooleanBody;
      }
    });
    Object.defineProperty(exports, "EnumBooleanMember", {
      enumerable: true,
      get: function() {
        return _index.enumBooleanMember;
      }
    });
    Object.defineProperty(exports, "EnumDeclaration", {
      enumerable: true,
      get: function() {
        return _index.enumDeclaration;
      }
    });
    Object.defineProperty(exports, "EnumDefaultedMember", {
      enumerable: true,
      get: function() {
        return _index.enumDefaultedMember;
      }
    });
    Object.defineProperty(exports, "EnumNumberBody", {
      enumerable: true,
      get: function() {
        return _index.enumNumberBody;
      }
    });
    Object.defineProperty(exports, "EnumNumberMember", {
      enumerable: true,
      get: function() {
        return _index.enumNumberMember;
      }
    });
    Object.defineProperty(exports, "EnumStringBody", {
      enumerable: true,
      get: function() {
        return _index.enumStringBody;
      }
    });
    Object.defineProperty(exports, "EnumStringMember", {
      enumerable: true,
      get: function() {
        return _index.enumStringMember;
      }
    });
    Object.defineProperty(exports, "EnumSymbolBody", {
      enumerable: true,
      get: function() {
        return _index.enumSymbolBody;
      }
    });
    Object.defineProperty(exports, "ExistsTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.existsTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "ExportAllDeclaration", {
      enumerable: true,
      get: function() {
        return _index.exportAllDeclaration;
      }
    });
    Object.defineProperty(exports, "ExportDefaultDeclaration", {
      enumerable: true,
      get: function() {
        return _index.exportDefaultDeclaration;
      }
    });
    Object.defineProperty(exports, "ExportDefaultSpecifier", {
      enumerable: true,
      get: function() {
        return _index.exportDefaultSpecifier;
      }
    });
    Object.defineProperty(exports, "ExportNamedDeclaration", {
      enumerable: true,
      get: function() {
        return _index.exportNamedDeclaration;
      }
    });
    Object.defineProperty(exports, "ExportNamespaceSpecifier", {
      enumerable: true,
      get: function() {
        return _index.exportNamespaceSpecifier;
      }
    });
    Object.defineProperty(exports, "ExportSpecifier", {
      enumerable: true,
      get: function() {
        return _index.exportSpecifier;
      }
    });
    Object.defineProperty(exports, "ExpressionStatement", {
      enumerable: true,
      get: function() {
        return _index.expressionStatement;
      }
    });
    Object.defineProperty(exports, "File", {
      enumerable: true,
      get: function() {
        return _index.file;
      }
    });
    Object.defineProperty(exports, "ForInStatement", {
      enumerable: true,
      get: function() {
        return _index.forInStatement;
      }
    });
    Object.defineProperty(exports, "ForOfStatement", {
      enumerable: true,
      get: function() {
        return _index.forOfStatement;
      }
    });
    Object.defineProperty(exports, "ForStatement", {
      enumerable: true,
      get: function() {
        return _index.forStatement;
      }
    });
    Object.defineProperty(exports, "FunctionDeclaration", {
      enumerable: true,
      get: function() {
        return _index.functionDeclaration;
      }
    });
    Object.defineProperty(exports, "FunctionExpression", {
      enumerable: true,
      get: function() {
        return _index.functionExpression;
      }
    });
    Object.defineProperty(exports, "FunctionTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.functionTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "FunctionTypeParam", {
      enumerable: true,
      get: function() {
        return _index.functionTypeParam;
      }
    });
    Object.defineProperty(exports, "GenericTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.genericTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "Identifier", {
      enumerable: true,
      get: function() {
        return _index.identifier;
      }
    });
    Object.defineProperty(exports, "IfStatement", {
      enumerable: true,
      get: function() {
        return _index.ifStatement;
      }
    });
    Object.defineProperty(exports, "Import", {
      enumerable: true,
      get: function() {
        return _index.import;
      }
    });
    Object.defineProperty(exports, "ImportAttribute", {
      enumerable: true,
      get: function() {
        return _index.importAttribute;
      }
    });
    Object.defineProperty(exports, "ImportDeclaration", {
      enumerable: true,
      get: function() {
        return _index.importDeclaration;
      }
    });
    Object.defineProperty(exports, "ImportDefaultSpecifier", {
      enumerable: true,
      get: function() {
        return _index.importDefaultSpecifier;
      }
    });
    Object.defineProperty(exports, "ImportNamespaceSpecifier", {
      enumerable: true,
      get: function() {
        return _index.importNamespaceSpecifier;
      }
    });
    Object.defineProperty(exports, "ImportSpecifier", {
      enumerable: true,
      get: function() {
        return _index.importSpecifier;
      }
    });
    Object.defineProperty(exports, "IndexedAccessType", {
      enumerable: true,
      get: function() {
        return _index.indexedAccessType;
      }
    });
    Object.defineProperty(exports, "InferredPredicate", {
      enumerable: true,
      get: function() {
        return _index.inferredPredicate;
      }
    });
    Object.defineProperty(exports, "InterfaceDeclaration", {
      enumerable: true,
      get: function() {
        return _index.interfaceDeclaration;
      }
    });
    Object.defineProperty(exports, "InterfaceExtends", {
      enumerable: true,
      get: function() {
        return _index.interfaceExtends;
      }
    });
    Object.defineProperty(exports, "InterfaceTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.interfaceTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "InterpreterDirective", {
      enumerable: true,
      get: function() {
        return _index.interpreterDirective;
      }
    });
    Object.defineProperty(exports, "IntersectionTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.intersectionTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "JSXAttribute", {
      enumerable: true,
      get: function() {
        return _index.jsxAttribute;
      }
    });
    Object.defineProperty(exports, "JSXClosingElement", {
      enumerable: true,
      get: function() {
        return _index.jsxClosingElement;
      }
    });
    Object.defineProperty(exports, "JSXClosingFragment", {
      enumerable: true,
      get: function() {
        return _index.jsxClosingFragment;
      }
    });
    Object.defineProperty(exports, "JSXElement", {
      enumerable: true,
      get: function() {
        return _index.jsxElement;
      }
    });
    Object.defineProperty(exports, "JSXEmptyExpression", {
      enumerable: true,
      get: function() {
        return _index.jsxEmptyExpression;
      }
    });
    Object.defineProperty(exports, "JSXExpressionContainer", {
      enumerable: true,
      get: function() {
        return _index.jsxExpressionContainer;
      }
    });
    Object.defineProperty(exports, "JSXFragment", {
      enumerable: true,
      get: function() {
        return _index.jsxFragment;
      }
    });
    Object.defineProperty(exports, "JSXIdentifier", {
      enumerable: true,
      get: function() {
        return _index.jsxIdentifier;
      }
    });
    Object.defineProperty(exports, "JSXMemberExpression", {
      enumerable: true,
      get: function() {
        return _index.jsxMemberExpression;
      }
    });
    Object.defineProperty(exports, "JSXNamespacedName", {
      enumerable: true,
      get: function() {
        return _index.jsxNamespacedName;
      }
    });
    Object.defineProperty(exports, "JSXOpeningElement", {
      enumerable: true,
      get: function() {
        return _index.jsxOpeningElement;
      }
    });
    Object.defineProperty(exports, "JSXOpeningFragment", {
      enumerable: true,
      get: function() {
        return _index.jsxOpeningFragment;
      }
    });
    Object.defineProperty(exports, "JSXSpreadAttribute", {
      enumerable: true,
      get: function() {
        return _index.jsxSpreadAttribute;
      }
    });
    Object.defineProperty(exports, "JSXSpreadChild", {
      enumerable: true,
      get: function() {
        return _index.jsxSpreadChild;
      }
    });
    Object.defineProperty(exports, "JSXText", {
      enumerable: true,
      get: function() {
        return _index.jsxText;
      }
    });
    Object.defineProperty(exports, "LabeledStatement", {
      enumerable: true,
      get: function() {
        return _index.labeledStatement;
      }
    });
    Object.defineProperty(exports, "LogicalExpression", {
      enumerable: true,
      get: function() {
        return _index.logicalExpression;
      }
    });
    Object.defineProperty(exports, "MemberExpression", {
      enumerable: true,
      get: function() {
        return _index.memberExpression;
      }
    });
    Object.defineProperty(exports, "MetaProperty", {
      enumerable: true,
      get: function() {
        return _index.metaProperty;
      }
    });
    Object.defineProperty(exports, "MixedTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.mixedTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "ModuleExpression", {
      enumerable: true,
      get: function() {
        return _index.moduleExpression;
      }
    });
    Object.defineProperty(exports, "NewExpression", {
      enumerable: true,
      get: function() {
        return _index.newExpression;
      }
    });
    Object.defineProperty(exports, "Noop", {
      enumerable: true,
      get: function() {
        return _index.noop;
      }
    });
    Object.defineProperty(exports, "NullLiteral", {
      enumerable: true,
      get: function() {
        return _index.nullLiteral;
      }
    });
    Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.nullLiteralTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "NullableTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.nullableTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "NumberLiteral", {
      enumerable: true,
      get: function() {
        return _index.numberLiteral;
      }
    });
    Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.numberLiteralTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "NumberTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.numberTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "NumericLiteral", {
      enumerable: true,
      get: function() {
        return _index.numericLiteral;
      }
    });
    Object.defineProperty(exports, "ObjectExpression", {
      enumerable: true,
      get: function() {
        return _index.objectExpression;
      }
    });
    Object.defineProperty(exports, "ObjectMethod", {
      enumerable: true,
      get: function() {
        return _index.objectMethod;
      }
    });
    Object.defineProperty(exports, "ObjectPattern", {
      enumerable: true,
      get: function() {
        return _index.objectPattern;
      }
    });
    Object.defineProperty(exports, "ObjectProperty", {
      enumerable: true,
      get: function() {
        return _index.objectProperty;
      }
    });
    Object.defineProperty(exports, "ObjectTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.objectTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "ObjectTypeCallProperty", {
      enumerable: true,
      get: function() {
        return _index.objectTypeCallProperty;
      }
    });
    Object.defineProperty(exports, "ObjectTypeIndexer", {
      enumerable: true,
      get: function() {
        return _index.objectTypeIndexer;
      }
    });
    Object.defineProperty(exports, "ObjectTypeInternalSlot", {
      enumerable: true,
      get: function() {
        return _index.objectTypeInternalSlot;
      }
    });
    Object.defineProperty(exports, "ObjectTypeProperty", {
      enumerable: true,
      get: function() {
        return _index.objectTypeProperty;
      }
    });
    Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
      enumerable: true,
      get: function() {
        return _index.objectTypeSpreadProperty;
      }
    });
    Object.defineProperty(exports, "OpaqueType", {
      enumerable: true,
      get: function() {
        return _index.opaqueType;
      }
    });
    Object.defineProperty(exports, "OptionalCallExpression", {
      enumerable: true,
      get: function() {
        return _index.optionalCallExpression;
      }
    });
    Object.defineProperty(exports, "OptionalIndexedAccessType", {
      enumerable: true,
      get: function() {
        return _index.optionalIndexedAccessType;
      }
    });
    Object.defineProperty(exports, "OptionalMemberExpression", {
      enumerable: true,
      get: function() {
        return _index.optionalMemberExpression;
      }
    });
    Object.defineProperty(exports, "ParenthesizedExpression", {
      enumerable: true,
      get: function() {
        return _index.parenthesizedExpression;
      }
    });
    Object.defineProperty(exports, "PipelineBareFunction", {
      enumerable: true,
      get: function() {
        return _index.pipelineBareFunction;
      }
    });
    Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
      enumerable: true,
      get: function() {
        return _index.pipelinePrimaryTopicReference;
      }
    });
    Object.defineProperty(exports, "PipelineTopicExpression", {
      enumerable: true,
      get: function() {
        return _index.pipelineTopicExpression;
      }
    });
    Object.defineProperty(exports, "Placeholder", {
      enumerable: true,
      get: function() {
        return _index.placeholder;
      }
    });
    Object.defineProperty(exports, "PrivateName", {
      enumerable: true,
      get: function() {
        return _index.privateName;
      }
    });
    Object.defineProperty(exports, "Program", {
      enumerable: true,
      get: function() {
        return _index.program;
      }
    });
    Object.defineProperty(exports, "QualifiedTypeIdentifier", {
      enumerable: true,
      get: function() {
        return _index.qualifiedTypeIdentifier;
      }
    });
    Object.defineProperty(exports, "RecordExpression", {
      enumerable: true,
      get: function() {
        return _index.recordExpression;
      }
    });
    Object.defineProperty(exports, "RegExpLiteral", {
      enumerable: true,
      get: function() {
        return _index.regExpLiteral;
      }
    });
    Object.defineProperty(exports, "RegexLiteral", {
      enumerable: true,
      get: function() {
        return _index.regexLiteral;
      }
    });
    Object.defineProperty(exports, "RestElement", {
      enumerable: true,
      get: function() {
        return _index.restElement;
      }
    });
    Object.defineProperty(exports, "RestProperty", {
      enumerable: true,
      get: function() {
        return _index.restProperty;
      }
    });
    Object.defineProperty(exports, "ReturnStatement", {
      enumerable: true,
      get: function() {
        return _index.returnStatement;
      }
    });
    Object.defineProperty(exports, "SequenceExpression", {
      enumerable: true,
      get: function() {
        return _index.sequenceExpression;
      }
    });
    Object.defineProperty(exports, "SpreadElement", {
      enumerable: true,
      get: function() {
        return _index.spreadElement;
      }
    });
    Object.defineProperty(exports, "SpreadProperty", {
      enumerable: true,
      get: function() {
        return _index.spreadProperty;
      }
    });
    Object.defineProperty(exports, "StaticBlock", {
      enumerable: true,
      get: function() {
        return _index.staticBlock;
      }
    });
    Object.defineProperty(exports, "StringLiteral", {
      enumerable: true,
      get: function() {
        return _index.stringLiteral;
      }
    });
    Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.stringLiteralTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "StringTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.stringTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "Super", {
      enumerable: true,
      get: function() {
        return _index.super;
      }
    });
    Object.defineProperty(exports, "SwitchCase", {
      enumerable: true,
      get: function() {
        return _index.switchCase;
      }
    });
    Object.defineProperty(exports, "SwitchStatement", {
      enumerable: true,
      get: function() {
        return _index.switchStatement;
      }
    });
    Object.defineProperty(exports, "SymbolTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.symbolTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "TSAnyKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsAnyKeyword;
      }
    });
    Object.defineProperty(exports, "TSArrayType", {
      enumerable: true,
      get: function() {
        return _index.tsArrayType;
      }
    });
    Object.defineProperty(exports, "TSAsExpression", {
      enumerable: true,
      get: function() {
        return _index.tsAsExpression;
      }
    });
    Object.defineProperty(exports, "TSBigIntKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsBigIntKeyword;
      }
    });
    Object.defineProperty(exports, "TSBooleanKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsBooleanKeyword;
      }
    });
    Object.defineProperty(exports, "TSCallSignatureDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsCallSignatureDeclaration;
      }
    });
    Object.defineProperty(exports, "TSConditionalType", {
      enumerable: true,
      get: function() {
        return _index.tsConditionalType;
      }
    });
    Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsConstructSignatureDeclaration;
      }
    });
    Object.defineProperty(exports, "TSConstructorType", {
      enumerable: true,
      get: function() {
        return _index.tsConstructorType;
      }
    });
    Object.defineProperty(exports, "TSDeclareFunction", {
      enumerable: true,
      get: function() {
        return _index.tsDeclareFunction;
      }
    });
    Object.defineProperty(exports, "TSDeclareMethod", {
      enumerable: true,
      get: function() {
        return _index.tsDeclareMethod;
      }
    });
    Object.defineProperty(exports, "TSEnumDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsEnumDeclaration;
      }
    });
    Object.defineProperty(exports, "TSEnumMember", {
      enumerable: true,
      get: function() {
        return _index.tsEnumMember;
      }
    });
    Object.defineProperty(exports, "TSExportAssignment", {
      enumerable: true,
      get: function() {
        return _index.tsExportAssignment;
      }
    });
    Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
      enumerable: true,
      get: function() {
        return _index.tsExpressionWithTypeArguments;
      }
    });
    Object.defineProperty(exports, "TSExternalModuleReference", {
      enumerable: true,
      get: function() {
        return _index.tsExternalModuleReference;
      }
    });
    Object.defineProperty(exports, "TSFunctionType", {
      enumerable: true,
      get: function() {
        return _index.tsFunctionType;
      }
    });
    Object.defineProperty(exports, "TSImportEqualsDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsImportEqualsDeclaration;
      }
    });
    Object.defineProperty(exports, "TSImportType", {
      enumerable: true,
      get: function() {
        return _index.tsImportType;
      }
    });
    Object.defineProperty(exports, "TSIndexSignature", {
      enumerable: true,
      get: function() {
        return _index.tsIndexSignature;
      }
    });
    Object.defineProperty(exports, "TSIndexedAccessType", {
      enumerable: true,
      get: function() {
        return _index.tsIndexedAccessType;
      }
    });
    Object.defineProperty(exports, "TSInferType", {
      enumerable: true,
      get: function() {
        return _index.tsInferType;
      }
    });
    Object.defineProperty(exports, "TSInstantiationExpression", {
      enumerable: true,
      get: function() {
        return _index.tsInstantiationExpression;
      }
    });
    Object.defineProperty(exports, "TSInterfaceBody", {
      enumerable: true,
      get: function() {
        return _index.tsInterfaceBody;
      }
    });
    Object.defineProperty(exports, "TSInterfaceDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsInterfaceDeclaration;
      }
    });
    Object.defineProperty(exports, "TSIntersectionType", {
      enumerable: true,
      get: function() {
        return _index.tsIntersectionType;
      }
    });
    Object.defineProperty(exports, "TSIntrinsicKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsIntrinsicKeyword;
      }
    });
    Object.defineProperty(exports, "TSLiteralType", {
      enumerable: true,
      get: function() {
        return _index.tsLiteralType;
      }
    });
    Object.defineProperty(exports, "TSMappedType", {
      enumerable: true,
      get: function() {
        return _index.tsMappedType;
      }
    });
    Object.defineProperty(exports, "TSMethodSignature", {
      enumerable: true,
      get: function() {
        return _index.tsMethodSignature;
      }
    });
    Object.defineProperty(exports, "TSModuleBlock", {
      enumerable: true,
      get: function() {
        return _index.tsModuleBlock;
      }
    });
    Object.defineProperty(exports, "TSModuleDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsModuleDeclaration;
      }
    });
    Object.defineProperty(exports, "TSNamedTupleMember", {
      enumerable: true,
      get: function() {
        return _index.tsNamedTupleMember;
      }
    });
    Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsNamespaceExportDeclaration;
      }
    });
    Object.defineProperty(exports, "TSNeverKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsNeverKeyword;
      }
    });
    Object.defineProperty(exports, "TSNonNullExpression", {
      enumerable: true,
      get: function() {
        return _index.tsNonNullExpression;
      }
    });
    Object.defineProperty(exports, "TSNullKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsNullKeyword;
      }
    });
    Object.defineProperty(exports, "TSNumberKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsNumberKeyword;
      }
    });
    Object.defineProperty(exports, "TSObjectKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsObjectKeyword;
      }
    });
    Object.defineProperty(exports, "TSOptionalType", {
      enumerable: true,
      get: function() {
        return _index.tsOptionalType;
      }
    });
    Object.defineProperty(exports, "TSParameterProperty", {
      enumerable: true,
      get: function() {
        return _index.tsParameterProperty;
      }
    });
    Object.defineProperty(exports, "TSParenthesizedType", {
      enumerable: true,
      get: function() {
        return _index.tsParenthesizedType;
      }
    });
    Object.defineProperty(exports, "TSPropertySignature", {
      enumerable: true,
      get: function() {
        return _index.tsPropertySignature;
      }
    });
    Object.defineProperty(exports, "TSQualifiedName", {
      enumerable: true,
      get: function() {
        return _index.tsQualifiedName;
      }
    });
    Object.defineProperty(exports, "TSRestType", {
      enumerable: true,
      get: function() {
        return _index.tsRestType;
      }
    });
    Object.defineProperty(exports, "TSSatisfiesExpression", {
      enumerable: true,
      get: function() {
        return _index.tsSatisfiesExpression;
      }
    });
    Object.defineProperty(exports, "TSStringKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsStringKeyword;
      }
    });
    Object.defineProperty(exports, "TSSymbolKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsSymbolKeyword;
      }
    });
    Object.defineProperty(exports, "TSThisType", {
      enumerable: true,
      get: function() {
        return _index.tsThisType;
      }
    });
    Object.defineProperty(exports, "TSTupleType", {
      enumerable: true,
      get: function() {
        return _index.tsTupleType;
      }
    });
    Object.defineProperty(exports, "TSTypeAliasDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsTypeAliasDeclaration;
      }
    });
    Object.defineProperty(exports, "TSTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.tsTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "TSTypeAssertion", {
      enumerable: true,
      get: function() {
        return _index.tsTypeAssertion;
      }
    });
    Object.defineProperty(exports, "TSTypeLiteral", {
      enumerable: true,
      get: function() {
        return _index.tsTypeLiteral;
      }
    });
    Object.defineProperty(exports, "TSTypeOperator", {
      enumerable: true,
      get: function() {
        return _index.tsTypeOperator;
      }
    });
    Object.defineProperty(exports, "TSTypeParameter", {
      enumerable: true,
      get: function() {
        return _index.tsTypeParameter;
      }
    });
    Object.defineProperty(exports, "TSTypeParameterDeclaration", {
      enumerable: true,
      get: function() {
        return _index.tsTypeParameterDeclaration;
      }
    });
    Object.defineProperty(exports, "TSTypeParameterInstantiation", {
      enumerable: true,
      get: function() {
        return _index.tsTypeParameterInstantiation;
      }
    });
    Object.defineProperty(exports, "TSTypePredicate", {
      enumerable: true,
      get: function() {
        return _index.tsTypePredicate;
      }
    });
    Object.defineProperty(exports, "TSTypeQuery", {
      enumerable: true,
      get: function() {
        return _index.tsTypeQuery;
      }
    });
    Object.defineProperty(exports, "TSTypeReference", {
      enumerable: true,
      get: function() {
        return _index.tsTypeReference;
      }
    });
    Object.defineProperty(exports, "TSUndefinedKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsUndefinedKeyword;
      }
    });
    Object.defineProperty(exports, "TSUnionType", {
      enumerable: true,
      get: function() {
        return _index.tsUnionType;
      }
    });
    Object.defineProperty(exports, "TSUnknownKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsUnknownKeyword;
      }
    });
    Object.defineProperty(exports, "TSVoidKeyword", {
      enumerable: true,
      get: function() {
        return _index.tsVoidKeyword;
      }
    });
    Object.defineProperty(exports, "TaggedTemplateExpression", {
      enumerable: true,
      get: function() {
        return _index.taggedTemplateExpression;
      }
    });
    Object.defineProperty(exports, "TemplateElement", {
      enumerable: true,
      get: function() {
        return _index.templateElement;
      }
    });
    Object.defineProperty(exports, "TemplateLiteral", {
      enumerable: true,
      get: function() {
        return _index.templateLiteral;
      }
    });
    Object.defineProperty(exports, "ThisExpression", {
      enumerable: true,
      get: function() {
        return _index.thisExpression;
      }
    });
    Object.defineProperty(exports, "ThisTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.thisTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "ThrowStatement", {
      enumerable: true,
      get: function() {
        return _index.throwStatement;
      }
    });
    Object.defineProperty(exports, "TopicReference", {
      enumerable: true,
      get: function() {
        return _index.topicReference;
      }
    });
    Object.defineProperty(exports, "TryStatement", {
      enumerable: true,
      get: function() {
        return _index.tryStatement;
      }
    });
    Object.defineProperty(exports, "TupleExpression", {
      enumerable: true,
      get: function() {
        return _index.tupleExpression;
      }
    });
    Object.defineProperty(exports, "TupleTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.tupleTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "TypeAlias", {
      enumerable: true,
      get: function() {
        return _index.typeAlias;
      }
    });
    Object.defineProperty(exports, "TypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.typeAnnotation;
      }
    });
    Object.defineProperty(exports, "TypeCastExpression", {
      enumerable: true,
      get: function() {
        return _index.typeCastExpression;
      }
    });
    Object.defineProperty(exports, "TypeParameter", {
      enumerable: true,
      get: function() {
        return _index.typeParameter;
      }
    });
    Object.defineProperty(exports, "TypeParameterDeclaration", {
      enumerable: true,
      get: function() {
        return _index.typeParameterDeclaration;
      }
    });
    Object.defineProperty(exports, "TypeParameterInstantiation", {
      enumerable: true,
      get: function() {
        return _index.typeParameterInstantiation;
      }
    });
    Object.defineProperty(exports, "TypeofTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.typeofTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "UnaryExpression", {
      enumerable: true,
      get: function() {
        return _index.unaryExpression;
      }
    });
    Object.defineProperty(exports, "UnionTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.unionTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "UpdateExpression", {
      enumerable: true,
      get: function() {
        return _index.updateExpression;
      }
    });
    Object.defineProperty(exports, "V8IntrinsicIdentifier", {
      enumerable: true,
      get: function() {
        return _index.v8IntrinsicIdentifier;
      }
    });
    Object.defineProperty(exports, "VariableDeclaration", {
      enumerable: true,
      get: function() {
        return _index.variableDeclaration;
      }
    });
    Object.defineProperty(exports, "VariableDeclarator", {
      enumerable: true,
      get: function() {
        return _index.variableDeclarator;
      }
    });
    Object.defineProperty(exports, "Variance", {
      enumerable: true,
      get: function() {
        return _index.variance;
      }
    });
    Object.defineProperty(exports, "VoidTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _index.voidTypeAnnotation;
      }
    });
    Object.defineProperty(exports, "WhileStatement", {
      enumerable: true,
      get: function() {
        return _index.whileStatement;
      }
    });
    Object.defineProperty(exports, "WithStatement", {
      enumerable: true,
      get: function() {
        return _index.withStatement;
      }
    });
    Object.defineProperty(exports, "YieldExpression", {
      enumerable: true,
      get: function() {
        return _index.yieldExpression;
      }
    });
    var _index = require_generated2();
  }
});

// node_modules/@babel/types/lib/clone/cloneNode.js
var require_cloneNode = __commonJS({
  "node_modules/@babel/types/lib/clone/cloneNode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = cloneNode;
    var _definitions = require_definitions();
    var _generated = require_generated();
    var has2 = Function.call.bind(Object.prototype.hasOwnProperty);
    function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
      if (obj && typeof obj.type === "string") {
        return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
      }
      return obj;
    }
    function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
      if (Array.isArray(obj)) {
        return obj.map((node2) => cloneIfNode(node2, deep, withoutLoc, commentsCache));
      }
      return cloneIfNode(obj, deep, withoutLoc, commentsCache);
    }
    function cloneNode(node2, deep = true, withoutLoc = false) {
      return cloneNodeInternal(node2, deep, withoutLoc, /* @__PURE__ */ new Map());
    }
    function cloneNodeInternal(node2, deep = true, withoutLoc = false, commentsCache) {
      if (!node2)
        return node2;
      const {
        type
      } = node2;
      const newNode = {
        type: node2.type
      };
      if ((0, _generated.isIdentifier)(node2)) {
        newNode.name = node2.name;
        if (has2(node2, "optional") && typeof node2.optional === "boolean") {
          newNode.optional = node2.optional;
        }
        if (has2(node2, "typeAnnotation")) {
          newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node2.typeAnnotation, true, withoutLoc, commentsCache) : node2.typeAnnotation;
        }
      } else if (!has2(_definitions.NODE_FIELDS, type)) {
        throw new Error(`Unknown node type: "${type}"`);
      } else {
        for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
          if (has2(node2, field)) {
            if (deep) {
              newNode[field] = (0, _generated.isFile)(node2) && field === "comments" ? maybeCloneComments(node2.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node2[field], true, withoutLoc, commentsCache);
            } else {
              newNode[field] = node2[field];
            }
          }
        }
      }
      if (has2(node2, "loc")) {
        if (withoutLoc) {
          newNode.loc = null;
        } else {
          newNode.loc = node2.loc;
        }
      }
      if (has2(node2, "leadingComments")) {
        newNode.leadingComments = maybeCloneComments(node2.leadingComments, deep, withoutLoc, commentsCache);
      }
      if (has2(node2, "innerComments")) {
        newNode.innerComments = maybeCloneComments(node2.innerComments, deep, withoutLoc, commentsCache);
      }
      if (has2(node2, "trailingComments")) {
        newNode.trailingComments = maybeCloneComments(node2.trailingComments, deep, withoutLoc, commentsCache);
      }
      if (has2(node2, "extra")) {
        newNode.extra = Object.assign({}, node2.extra);
      }
      return newNode;
    }
    function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
      if (!comments || !deep) {
        return comments;
      }
      return comments.map((comment2) => {
        const cache = commentsCache.get(comment2);
        if (cache)
          return cache;
        const {
          type,
          value: value2,
          loc
        } = comment2;
        const ret = {
          type,
          value: value2,
          loc
        };
        if (withoutLoc) {
          ret.loc = null;
        }
        commentsCache.set(comment2, ret);
        return ret;
      });
    }
  }
});

// node_modules/@babel/types/lib/clone/clone.js
var require_clone = __commonJS({
  "node_modules/@babel/types/lib/clone/clone.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = clone;
    var _cloneNode = require_cloneNode();
    function clone(node2) {
      return (0, _cloneNode.default)(node2, false);
    }
  }
});

// node_modules/@babel/types/lib/clone/cloneDeep.js
var require_cloneDeep = __commonJS({
  "node_modules/@babel/types/lib/clone/cloneDeep.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = cloneDeep2;
    var _cloneNode = require_cloneNode();
    function cloneDeep2(node2) {
      return (0, _cloneNode.default)(node2);
    }
  }
});

// node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
var require_cloneDeepWithoutLoc = __commonJS({
  "node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = cloneDeepWithoutLoc;
    var _cloneNode = require_cloneNode();
    function cloneDeepWithoutLoc(node2) {
      return (0, _cloneNode.default)(node2, true, true);
    }
  }
});

// node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
var require_cloneWithoutLoc = __commonJS({
  "node_modules/@babel/types/lib/clone/cloneWithoutLoc.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = cloneWithoutLoc;
    var _cloneNode = require_cloneNode();
    function cloneWithoutLoc(node2) {
      return (0, _cloneNode.default)(node2, false, true);
    }
  }
});

// node_modules/@babel/types/lib/comments/addComments.js
var require_addComments = __commonJS({
  "node_modules/@babel/types/lib/comments/addComments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = addComments;
    function addComments(node2, type, comments) {
      if (!comments || !node2)
        return node2;
      const key2 = `${type}Comments`;
      if (node2[key2]) {
        if (type === "leading") {
          node2[key2] = comments.concat(node2[key2]);
        } else {
          node2[key2].push(...comments);
        }
      } else {
        node2[key2] = comments;
      }
      return node2;
    }
  }
});

// node_modules/@babel/types/lib/comments/addComment.js
var require_addComment = __commonJS({
  "node_modules/@babel/types/lib/comments/addComment.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = addComment;
    var _addComments = require_addComments();
    function addComment(node2, type, content3, line2) {
      return (0, _addComments.default)(node2, type, [{
        type: line2 ? "CommentLine" : "CommentBlock",
        value: content3
      }]);
    }
  }
});

// node_modules/@babel/types/lib/utils/inherit.js
var require_inherit = __commonJS({
  "node_modules/@babel/types/lib/utils/inherit.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = inherit2;
    function inherit2(key2, child, parent) {
      if (child && parent) {
        child[key2] = Array.from(new Set([].concat(child[key2], parent[key2]).filter(Boolean)));
      }
    }
  }
});

// node_modules/@babel/types/lib/comments/inheritInnerComments.js
var require_inheritInnerComments = __commonJS({
  "node_modules/@babel/types/lib/comments/inheritInnerComments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = inheritInnerComments;
    var _inherit = require_inherit();
    function inheritInnerComments(child, parent) {
      (0, _inherit.default)("innerComments", child, parent);
    }
  }
});

// node_modules/@babel/types/lib/comments/inheritLeadingComments.js
var require_inheritLeadingComments = __commonJS({
  "node_modules/@babel/types/lib/comments/inheritLeadingComments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = inheritLeadingComments;
    var _inherit = require_inherit();
    function inheritLeadingComments(child, parent) {
      (0, _inherit.default)("leadingComments", child, parent);
    }
  }
});

// node_modules/@babel/types/lib/comments/inheritTrailingComments.js
var require_inheritTrailingComments = __commonJS({
  "node_modules/@babel/types/lib/comments/inheritTrailingComments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = inheritTrailingComments;
    var _inherit = require_inherit();
    function inheritTrailingComments(child, parent) {
      (0, _inherit.default)("trailingComments", child, parent);
    }
  }
});

// node_modules/@babel/types/lib/comments/inheritsComments.js
var require_inheritsComments = __commonJS({
  "node_modules/@babel/types/lib/comments/inheritsComments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = inheritsComments;
    var _inheritTrailingComments = require_inheritTrailingComments();
    var _inheritLeadingComments = require_inheritLeadingComments();
    var _inheritInnerComments = require_inheritInnerComments();
    function inheritsComments(child, parent) {
      (0, _inheritTrailingComments.default)(child, parent);
      (0, _inheritLeadingComments.default)(child, parent);
      (0, _inheritInnerComments.default)(child, parent);
      return child;
    }
  }
});

// node_modules/@babel/types/lib/comments/removeComments.js
var require_removeComments = __commonJS({
  "node_modules/@babel/types/lib/comments/removeComments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = removeComments;
    var _constants = require_constants();
    function removeComments(node2) {
      _constants.COMMENT_KEYS.forEach((key2) => {
        node2[key2] = null;
      });
      return node2;
    }
  }
});

// node_modules/@babel/types/lib/constants/generated/index.js
var require_generated4 = __commonJS({
  "node_modules/@babel/types/lib/constants/generated/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;
    var _definitions = require_definitions();
    var STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"];
    exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES;
    var EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
    exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
    var BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
    exports.BINARY_TYPES = BINARY_TYPES;
    var SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
    exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
    var BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
    exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
    var BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
    exports.BLOCK_TYPES = BLOCK_TYPES;
    var STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
    exports.STATEMENT_TYPES = STATEMENT_TYPES;
    var TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
    exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
    var COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
    exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
    var CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
    exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
    var LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
    exports.LOOP_TYPES = LOOP_TYPES;
    var WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
    exports.WHILE_TYPES = WHILE_TYPES;
    var EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
    exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
    var FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
    exports.FOR_TYPES = FOR_TYPES;
    var FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
    exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
    var FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
    exports.FUNCTION_TYPES = FUNCTION_TYPES;
    var FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
    exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
    var PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
    exports.PUREISH_TYPES = PUREISH_TYPES;
    var DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
    exports.DECLARATION_TYPES = DECLARATION_TYPES;
    var PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
    exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
    var LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
    exports.LVAL_TYPES = LVAL_TYPES;
    var TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
    exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
    var LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
    exports.LITERAL_TYPES = LITERAL_TYPES;
    var IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
    exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
    var USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
    exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
    var METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
    exports.METHOD_TYPES = METHOD_TYPES;
    var OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
    exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
    var PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
    exports.PROPERTY_TYPES = PROPERTY_TYPES;
    var UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
    exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
    var PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
    exports.PATTERN_TYPES = PATTERN_TYPES;
    var CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
    exports.CLASS_TYPES = CLASS_TYPES;
    var IMPORTOREXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
    exports.IMPORTOREXPORTDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
    var EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
    exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
    var MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
    exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
    var ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"];
    exports.ACCESSOR_TYPES = ACCESSOR_TYPES;
    var PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
    exports.PRIVATE_TYPES = PRIVATE_TYPES;
    var FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
    exports.FLOW_TYPES = FLOW_TYPES;
    var FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
    exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
    var FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
    exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
    var FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
    exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
    var FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
    exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
    var ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"];
    exports.ENUMBODY_TYPES = ENUMBODY_TYPES;
    var ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"];
    exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
    var JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
    exports.JSX_TYPES = JSX_TYPES;
    var MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"];
    exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES;
    var TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"];
    exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES;
    var TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
    exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
    var TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
    exports.TSTYPE_TYPES = TSTYPE_TYPES;
    var TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"];
    exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
    var MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
    exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
  }
});

// node_modules/@babel/types/lib/converters/toBlock.js
var require_toBlock = __commonJS({
  "node_modules/@babel/types/lib/converters/toBlock.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = toBlock;
    var _generated = require_generated();
    var _generated2 = require_generated2();
    function toBlock(node2, parent) {
      if ((0, _generated.isBlockStatement)(node2)) {
        return node2;
      }
      let blockNodes = [];
      if ((0, _generated.isEmptyStatement)(node2)) {
        blockNodes = [];
      } else {
        if (!(0, _generated.isStatement)(node2)) {
          if ((0, _generated.isFunction)(parent)) {
            node2 = (0, _generated2.returnStatement)(node2);
          } else {
            node2 = (0, _generated2.expressionStatement)(node2);
          }
        }
        blockNodes = [node2];
      }
      return (0, _generated2.blockStatement)(blockNodes);
    }
  }
});

// node_modules/@babel/types/lib/converters/ensureBlock.js
var require_ensureBlock = __commonJS({
  "node_modules/@babel/types/lib/converters/ensureBlock.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = ensureBlock;
    var _toBlock = require_toBlock();
    function ensureBlock(node2, key2 = "body") {
      const result = (0, _toBlock.default)(node2[key2], node2);
      node2[key2] = result;
      return result;
    }
  }
});

// node_modules/@babel/types/lib/converters/toIdentifier.js
var require_toIdentifier = __commonJS({
  "node_modules/@babel/types/lib/converters/toIdentifier.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = toIdentifier2;
    var _isValidIdentifier = require_isValidIdentifier();
    var _helperValidatorIdentifier = require_lib();
    function toIdentifier2(input) {
      input = input + "";
      let name2 = "";
      for (const c2 of input) {
        name2 += (0, _helperValidatorIdentifier.isIdentifierChar)(c2.codePointAt(0)) ? c2 : "-";
      }
      name2 = name2.replace(/^[-0-9]+/, "");
      name2 = name2.replace(/[-\s]+(.)?/g, function(match, c2) {
        return c2 ? c2.toUpperCase() : "";
      });
      if (!(0, _isValidIdentifier.default)(name2)) {
        name2 = `_${name2}`;
      }
      return name2 || "_";
    }
  }
});

// node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
var require_toBindingIdentifierName = __commonJS({
  "node_modules/@babel/types/lib/converters/toBindingIdentifierName.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = toBindingIdentifierName;
    var _toIdentifier = require_toIdentifier();
    function toBindingIdentifierName(name2) {
      name2 = (0, _toIdentifier.default)(name2);
      if (name2 === "eval" || name2 === "arguments")
        name2 = "_" + name2;
      return name2;
    }
  }
});

// node_modules/@babel/types/lib/converters/toComputedKey.js
var require_toComputedKey = __commonJS({
  "node_modules/@babel/types/lib/converters/toComputedKey.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = toComputedKey;
    var _generated = require_generated();
    var _generated2 = require_generated2();
    function toComputedKey(node2, key2 = node2.key || node2.property) {
      if (!node2.computed && (0, _generated.isIdentifier)(key2))
        key2 = (0, _generated2.stringLiteral)(key2.name);
      return key2;
    }
  }
});

// node_modules/@babel/types/lib/converters/toExpression.js
var require_toExpression = __commonJS({
  "node_modules/@babel/types/lib/converters/toExpression.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _generated = require_generated();
    var _default = toExpression;
    exports.default = _default;
    function toExpression(node2) {
      if ((0, _generated.isExpressionStatement)(node2)) {
        node2 = node2.expression;
      }
      if ((0, _generated.isExpression)(node2)) {
        return node2;
      }
      if ((0, _generated.isClass)(node2)) {
        node2.type = "ClassExpression";
      } else if ((0, _generated.isFunction)(node2)) {
        node2.type = "FunctionExpression";
      }
      if (!(0, _generated.isExpression)(node2)) {
        throw new Error(`cannot turn ${node2.type} to an expression`);
      }
      return node2;
    }
  }
});

// node_modules/@babel/types/lib/traverse/traverseFast.js
var require_traverseFast = __commonJS({
  "node_modules/@babel/types/lib/traverse/traverseFast.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = traverseFast;
    var _definitions = require_definitions();
    function traverseFast(node2, enter, opts) {
      if (!node2)
        return;
      const keys2 = _definitions.VISITOR_KEYS[node2.type];
      if (!keys2)
        return;
      opts = opts || {};
      enter(node2, opts);
      for (const key2 of keys2) {
        const subNode = node2[key2];
        if (Array.isArray(subNode)) {
          for (const node3 of subNode) {
            traverseFast(node3, enter, opts);
          }
        } else {
          traverseFast(subNode, enter, opts);
        }
      }
    }
  }
});

// node_modules/@babel/types/lib/modifications/removeProperties.js
var require_removeProperties = __commonJS({
  "node_modules/@babel/types/lib/modifications/removeProperties.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = removeProperties;
    var _constants = require_constants();
    var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
    var CLEAR_KEYS_PLUS_COMMENTS = [..._constants.COMMENT_KEYS, "comments", ...CLEAR_KEYS];
    function removeProperties(node2, opts = {}) {
      const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
      for (const key2 of map) {
        if (node2[key2] != null)
          node2[key2] = void 0;
      }
      for (const key2 of Object.keys(node2)) {
        if (key2[0] === "_" && node2[key2] != null)
          node2[key2] = void 0;
      }
      const symbols = Object.getOwnPropertySymbols(node2);
      for (const sym of symbols) {
        node2[sym] = null;
      }
    }
  }
});

// node_modules/@babel/types/lib/modifications/removePropertiesDeep.js
var require_removePropertiesDeep = __commonJS({
  "node_modules/@babel/types/lib/modifications/removePropertiesDeep.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = removePropertiesDeep;
    var _traverseFast = require_traverseFast();
    var _removeProperties = require_removeProperties();
    function removePropertiesDeep(tree, opts) {
      (0, _traverseFast.default)(tree, _removeProperties.default, opts);
      return tree;
    }
  }
});

// node_modules/@babel/types/lib/converters/toKeyAlias.js
var require_toKeyAlias = __commonJS({
  "node_modules/@babel/types/lib/converters/toKeyAlias.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = toKeyAlias;
    var _generated = require_generated();
    var _cloneNode = require_cloneNode();
    var _removePropertiesDeep = require_removePropertiesDeep();
    function toKeyAlias(node2, key2 = node2.key) {
      let alias;
      if (node2.kind === "method") {
        return toKeyAlias.increment() + "";
      } else if ((0, _generated.isIdentifier)(key2)) {
        alias = key2.name;
      } else if ((0, _generated.isStringLiteral)(key2)) {
        alias = JSON.stringify(key2.value);
      } else {
        alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key2)));
      }
      if (node2.computed) {
        alias = `[${alias}]`;
      }
      if (node2.static) {
        alias = `static:${alias}`;
      }
      return alias;
    }
    toKeyAlias.uid = 0;
    toKeyAlias.increment = function() {
      if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
        return toKeyAlias.uid = 0;
      } else {
        return toKeyAlias.uid++;
      }
    };
  }
});

// node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js
var require_getBindingIdentifiers = __commonJS({
  "node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = getBindingIdentifiers;
    var _generated = require_generated();
    function getBindingIdentifiers(node2, duplicates, outerOnly) {
      const search2 = [].concat(node2);
      const ids = /* @__PURE__ */ Object.create(null);
      while (search2.length) {
        const id = search2.shift();
        if (!id)
          continue;
        const keys2 = getBindingIdentifiers.keys[id.type];
        if ((0, _generated.isIdentifier)(id)) {
          if (duplicates) {
            const _ids = ids[id.name] = ids[id.name] || [];
            _ids.push(id);
          } else {
            ids[id.name] = id;
          }
          continue;
        }
        if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) {
          if ((0, _generated.isDeclaration)(id.declaration)) {
            search2.push(id.declaration);
          }
          continue;
        }
        if (outerOnly) {
          if ((0, _generated.isFunctionDeclaration)(id)) {
            search2.push(id.id);
            continue;
          }
          if ((0, _generated.isFunctionExpression)(id)) {
            continue;
          }
        }
        if (keys2) {
          for (let i = 0; i < keys2.length; i++) {
            const key2 = keys2[i];
            const nodes = id[key2];
            if (nodes) {
              Array.isArray(nodes) ? search2.push(...nodes) : search2.push(nodes);
            }
          }
        }
      }
      return ids;
    }
    getBindingIdentifiers.keys = {
      DeclareClass: ["id"],
      DeclareFunction: ["id"],
      DeclareModule: ["id"],
      DeclareVariable: ["id"],
      DeclareInterface: ["id"],
      DeclareTypeAlias: ["id"],
      DeclareOpaqueType: ["id"],
      InterfaceDeclaration: ["id"],
      TypeAlias: ["id"],
      OpaqueType: ["id"],
      CatchClause: ["param"],
      LabeledStatement: ["label"],
      UnaryExpression: ["argument"],
      AssignmentExpression: ["left"],
      ImportSpecifier: ["local"],
      ImportNamespaceSpecifier: ["local"],
      ImportDefaultSpecifier: ["local"],
      ImportDeclaration: ["specifiers"],
      ExportSpecifier: ["exported"],
      ExportNamespaceSpecifier: ["exported"],
      ExportDefaultSpecifier: ["exported"],
      FunctionDeclaration: ["id", "params"],
      FunctionExpression: ["id", "params"],
      ArrowFunctionExpression: ["params"],
      ObjectMethod: ["params"],
      ClassMethod: ["params"],
      ClassPrivateMethod: ["params"],
      ForInStatement: ["left"],
      ForOfStatement: ["left"],
      ClassDeclaration: ["id"],
      ClassExpression: ["id"],
      RestElement: ["argument"],
      UpdateExpression: ["argument"],
      ObjectProperty: ["value"],
      AssignmentPattern: ["left"],
      ArrayPattern: ["elements"],
      ObjectPattern: ["properties"],
      VariableDeclaration: ["declarations"],
      VariableDeclarator: ["id"]
    };
  }
});

// node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
var require_gatherSequenceExpressions = __commonJS({
  "node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = gatherSequenceExpressions;
    var _getBindingIdentifiers = require_getBindingIdentifiers();
    var _generated = require_generated();
    var _generated2 = require_generated2();
    var _cloneNode = require_cloneNode();
    function gatherSequenceExpressions(nodes, scope, declars) {
      const exprs = [];
      let ensureLastUndefined = true;
      for (const node2 of nodes) {
        if (!(0, _generated.isEmptyStatement)(node2)) {
          ensureLastUndefined = false;
        }
        if ((0, _generated.isExpression)(node2)) {
          exprs.push(node2);
        } else if ((0, _generated.isExpressionStatement)(node2)) {
          exprs.push(node2.expression);
        } else if ((0, _generated.isVariableDeclaration)(node2)) {
          if (node2.kind !== "var")
            return;
          for (const declar of node2.declarations) {
            const bindings = (0, _getBindingIdentifiers.default)(declar);
            for (const key2 of Object.keys(bindings)) {
              declars.push({
                kind: node2.kind,
                id: (0, _cloneNode.default)(bindings[key2])
              });
            }
            if (declar.init) {
              exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
            }
          }
          ensureLastUndefined = true;
        } else if ((0, _generated.isIfStatement)(node2)) {
          const consequent = node2.consequent ? gatherSequenceExpressions([node2.consequent], scope, declars) : scope.buildUndefinedNode();
          const alternate = node2.alternate ? gatherSequenceExpressions([node2.alternate], scope, declars) : scope.buildUndefinedNode();
          if (!consequent || !alternate)
            return;
          exprs.push((0, _generated2.conditionalExpression)(node2.test, consequent, alternate));
        } else if ((0, _generated.isBlockStatement)(node2)) {
          const body = gatherSequenceExpressions(node2.body, scope, declars);
          if (!body)
            return;
          exprs.push(body);
        } else if ((0, _generated.isEmptyStatement)(node2)) {
          if (nodes.indexOf(node2) === 0) {
            ensureLastUndefined = true;
          }
        } else {
          return;
        }
      }
      if (ensureLastUndefined) {
        exprs.push(scope.buildUndefinedNode());
      }
      if (exprs.length === 1) {
        return exprs[0];
      } else {
        return (0, _generated2.sequenceExpression)(exprs);
      }
    }
  }
});

// node_modules/@babel/types/lib/converters/toSequenceExpression.js
var require_toSequenceExpression = __commonJS({
  "node_modules/@babel/types/lib/converters/toSequenceExpression.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = toSequenceExpression;
    var _gatherSequenceExpressions = require_gatherSequenceExpressions();
    function toSequenceExpression(nodes, scope) {
      if (!(nodes != null && nodes.length))
        return;
      const declars = [];
      const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
      if (!result)
        return;
      for (const declar of declars) {
        scope.push(declar);
      }
      return result;
    }
  }
});

// node_modules/@babel/types/lib/converters/toStatement.js
var require_toStatement = __commonJS({
  "node_modules/@babel/types/lib/converters/toStatement.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _generated = require_generated();
    var _generated2 = require_generated2();
    var _default = toStatement;
    exports.default = _default;
    function toStatement(node2, ignore3) {
      if ((0, _generated.isStatement)(node2)) {
        return node2;
      }
      let mustHaveId = false;
      let newType;
      if ((0, _generated.isClass)(node2)) {
        mustHaveId = true;
        newType = "ClassDeclaration";
      } else if ((0, _generated.isFunction)(node2)) {
        mustHaveId = true;
        newType = "FunctionDeclaration";
      } else if ((0, _generated.isAssignmentExpression)(node2)) {
        return (0, _generated2.expressionStatement)(node2);
      }
      if (mustHaveId && !node2.id) {
        newType = false;
      }
      if (!newType) {
        if (ignore3) {
          return false;
        } else {
          throw new Error(`cannot turn ${node2.type} to a statement`);
        }
      }
      node2.type = newType;
      return node2;
    }
  }
});

// node_modules/@babel/types/lib/converters/valueToNode.js
var require_valueToNode = __commonJS({
  "node_modules/@babel/types/lib/converters/valueToNode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _isValidIdentifier = require_isValidIdentifier();
    var _generated = require_generated2();
    var _default = valueToNode;
    exports.default = _default;
    var objectToString = Function.call.bind(Object.prototype.toString);
    function isRegExp(value2) {
      return objectToString(value2) === "[object RegExp]";
    }
    function isPlainObject2(value2) {
      if (typeof value2 !== "object" || value2 === null || Object.prototype.toString.call(value2) !== "[object Object]") {
        return false;
      }
      const proto = Object.getPrototypeOf(value2);
      return proto === null || Object.getPrototypeOf(proto) === null;
    }
    function valueToNode(value2) {
      if (value2 === void 0) {
        return (0, _generated.identifier)("undefined");
      }
      if (value2 === true || value2 === false) {
        return (0, _generated.booleanLiteral)(value2);
      }
      if (value2 === null) {
        return (0, _generated.nullLiteral)();
      }
      if (typeof value2 === "string") {
        return (0, _generated.stringLiteral)(value2);
      }
      if (typeof value2 === "number") {
        let result;
        if (Number.isFinite(value2)) {
          result = (0, _generated.numericLiteral)(Math.abs(value2));
        } else {
          let numerator;
          if (Number.isNaN(value2)) {
            numerator = (0, _generated.numericLiteral)(0);
          } else {
            numerator = (0, _generated.numericLiteral)(1);
          }
          result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
        }
        if (value2 < 0 || Object.is(value2, -0)) {
          result = (0, _generated.unaryExpression)("-", result);
        }
        return result;
      }
      if (isRegExp(value2)) {
        const pattern = value2.source;
        const flags = value2.toString().match(/\/([a-z]+|)$/)[1];
        return (0, _generated.regExpLiteral)(pattern, flags);
      }
      if (Array.isArray(value2)) {
        return (0, _generated.arrayExpression)(value2.map(valueToNode));
      }
      if (isPlainObject2(value2)) {
        const props = [];
        for (const key2 of Object.keys(value2)) {
          let nodeKey;
          if ((0, _isValidIdentifier.default)(key2)) {
            nodeKey = (0, _generated.identifier)(key2);
          } else {
            nodeKey = (0, _generated.stringLiteral)(key2);
          }
          props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value2[key2])));
        }
        return (0, _generated.objectExpression)(props);
      }
      throw new Error("don't know how to turn this value into a node");
    }
  }
});

// node_modules/@babel/types/lib/modifications/appendToMemberExpression.js
var require_appendToMemberExpression = __commonJS({
  "node_modules/@babel/types/lib/modifications/appendToMemberExpression.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = appendToMemberExpression;
    var _generated = require_generated2();
    function appendToMemberExpression(member, append, computed = false) {
      member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
      member.property = append;
      member.computed = !!computed;
      return member;
    }
  }
});

// node_modules/@babel/types/lib/modifications/inherits.js
var require_inherits = __commonJS({
  "node_modules/@babel/types/lib/modifications/inherits.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = inherits;
    var _constants = require_constants();
    var _inheritsComments = require_inheritsComments();
    function inherits(child, parent) {
      if (!child || !parent)
        return child;
      for (const key2 of _constants.INHERIT_KEYS.optional) {
        if (child[key2] == null) {
          child[key2] = parent[key2];
        }
      }
      for (const key2 of Object.keys(parent)) {
        if (key2[0] === "_" && key2 !== "__clone") {
          child[key2] = parent[key2];
        }
      }
      for (const key2 of _constants.INHERIT_KEYS.force) {
        child[key2] = parent[key2];
      }
      (0, _inheritsComments.default)(child, parent);
      return child;
    }
  }
});

// node_modules/@babel/types/lib/modifications/prependToMemberExpression.js
var require_prependToMemberExpression = __commonJS({
  "node_modules/@babel/types/lib/modifications/prependToMemberExpression.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = prependToMemberExpression;
    var _generated = require_generated2();
    var _ = require_lib3();
    function prependToMemberExpression(member, prepend) {
      if ((0, _.isSuper)(member.object)) {
        throw new Error("Cannot prepend node to super property access (`super.foo`).");
      }
      member.object = (0, _generated.memberExpression)(prepend, member.object);
      return member;
    }
  }
});

// node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js
var require_getOuterBindingIdentifiers = __commonJS({
  "node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _getBindingIdentifiers = require_getBindingIdentifiers();
    var _default = getOuterBindingIdentifiers;
    exports.default = _default;
    function getOuterBindingIdentifiers(node2, duplicates) {
      return (0, _getBindingIdentifiers.default)(node2, duplicates, true);
    }
  }
});

// node_modules/@babel/types/lib/traverse/traverse.js
var require_traverse = __commonJS({
  "node_modules/@babel/types/lib/traverse/traverse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = traverse;
    var _definitions = require_definitions();
    function traverse(node2, handlers3, state) {
      if (typeof handlers3 === "function") {
        handlers3 = {
          enter: handlers3
        };
      }
      const {
        enter,
        exit: exit2
      } = handlers3;
      traverseSimpleImpl(node2, enter, exit2, state, []);
    }
    function traverseSimpleImpl(node2, enter, exit2, state, ancestors) {
      const keys2 = _definitions.VISITOR_KEYS[node2.type];
      if (!keys2)
        return;
      if (enter)
        enter(node2, ancestors, state);
      for (const key2 of keys2) {
        const subNode = node2[key2];
        if (Array.isArray(subNode)) {
          for (let i = 0; i < subNode.length; i++) {
            const child = subNode[i];
            if (!child)
              continue;
            ancestors.push({
              node: node2,
              key: key2,
              index: i
            });
            traverseSimpleImpl(child, enter, exit2, state, ancestors);
            ancestors.pop();
          }
        } else if (subNode) {
          ancestors.push({
            node: node2,
            key: key2
          });
          traverseSimpleImpl(subNode, enter, exit2, state, ancestors);
          ancestors.pop();
        }
      }
      if (exit2)
        exit2(node2, ancestors, state);
    }
  }
});

// node_modules/@babel/types/lib/validators/isBinding.js
var require_isBinding = __commonJS({
  "node_modules/@babel/types/lib/validators/isBinding.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isBinding;
    var _getBindingIdentifiers = require_getBindingIdentifiers();
    function isBinding(node2, parent, grandparent) {
      if (grandparent && node2.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
        return false;
      }
      const keys2 = _getBindingIdentifiers.default.keys[parent.type];
      if (keys2) {
        for (let i = 0; i < keys2.length; i++) {
          const key2 = keys2[i];
          const val = parent[key2];
          if (Array.isArray(val)) {
            if (val.indexOf(node2) >= 0)
              return true;
          } else {
            if (val === node2)
              return true;
          }
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/types/lib/validators/isLet.js
var require_isLet = __commonJS({
  "node_modules/@babel/types/lib/validators/isLet.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isLet;
    var _generated = require_generated();
    var _constants = require_constants();
    function isLet(node2) {
      return (0, _generated.isVariableDeclaration)(node2) && (node2.kind !== "var" || node2[_constants.BLOCK_SCOPED_SYMBOL]);
    }
  }
});

// node_modules/@babel/types/lib/validators/isBlockScoped.js
var require_isBlockScoped = __commonJS({
  "node_modules/@babel/types/lib/validators/isBlockScoped.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isBlockScoped;
    var _generated = require_generated();
    var _isLet = require_isLet();
    function isBlockScoped(node2) {
      return (0, _generated.isFunctionDeclaration)(node2) || (0, _generated.isClassDeclaration)(node2) || (0, _isLet.default)(node2);
    }
  }
});

// node_modules/@babel/types/lib/validators/isImmutable.js
var require_isImmutable = __commonJS({
  "node_modules/@babel/types/lib/validators/isImmutable.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isImmutable;
    var _isType = require_isType();
    var _generated = require_generated();
    function isImmutable(node2) {
      if ((0, _isType.default)(node2.type, "Immutable"))
        return true;
      if ((0, _generated.isIdentifier)(node2)) {
        if (node2.name === "undefined") {
          return true;
        } else {
          return false;
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/types/lib/validators/isNodesEquivalent.js
var require_isNodesEquivalent = __commonJS({
  "node_modules/@babel/types/lib/validators/isNodesEquivalent.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isNodesEquivalent;
    var _definitions = require_definitions();
    function isNodesEquivalent(a, b) {
      if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
        return a === b;
      }
      if (a.type !== b.type) {
        return false;
      }
      const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type);
      const visitorKeys = _definitions.VISITOR_KEYS[a.type];
      for (const field of fields) {
        const val_a = a[field];
        const val_b = b[field];
        if (typeof val_a !== typeof val_b) {
          return false;
        }
        if (val_a == null && val_b == null) {
          continue;
        } else if (val_a == null || val_b == null) {
          return false;
        }
        if (Array.isArray(val_a)) {
          if (!Array.isArray(val_b)) {
            return false;
          }
          if (val_a.length !== val_b.length) {
            return false;
          }
          for (let i = 0; i < val_a.length; i++) {
            if (!isNodesEquivalent(val_a[i], val_b[i])) {
              return false;
            }
          }
          continue;
        }
        if (typeof val_a === "object" && !(visitorKeys != null && visitorKeys.includes(field))) {
          for (const key2 of Object.keys(val_a)) {
            if (val_a[key2] !== val_b[key2]) {
              return false;
            }
          }
          continue;
        }
        if (!isNodesEquivalent(val_a, val_b)) {
          return false;
        }
      }
      return true;
    }
  }
});

// node_modules/@babel/types/lib/validators/isReferenced.js
var require_isReferenced = __commonJS({
  "node_modules/@babel/types/lib/validators/isReferenced.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isReferenced;
    function isReferenced(node2, parent, grandparent) {
      switch (parent.type) {
        case "MemberExpression":
        case "OptionalMemberExpression":
          if (parent.property === node2) {
            return !!parent.computed;
          }
          return parent.object === node2;
        case "JSXMemberExpression":
          return parent.object === node2;
        case "VariableDeclarator":
          return parent.init === node2;
        case "ArrowFunctionExpression":
          return parent.body === node2;
        case "PrivateName":
          return false;
        case "ClassMethod":
        case "ClassPrivateMethod":
        case "ObjectMethod":
          if (parent.key === node2) {
            return !!parent.computed;
          }
          return false;
        case "ObjectProperty":
          if (parent.key === node2) {
            return !!parent.computed;
          }
          return !grandparent || grandparent.type !== "ObjectPattern";
        case "ClassProperty":
        case "ClassAccessorProperty":
          if (parent.key === node2) {
            return !!parent.computed;
          }
          return true;
        case "ClassPrivateProperty":
          return parent.key !== node2;
        case "ClassDeclaration":
        case "ClassExpression":
          return parent.superClass === node2;
        case "AssignmentExpression":
          return parent.right === node2;
        case "AssignmentPattern":
          return parent.right === node2;
        case "LabeledStatement":
          return false;
        case "CatchClause":
          return false;
        case "RestElement":
          return false;
        case "BreakStatement":
        case "ContinueStatement":
          return false;
        case "FunctionDeclaration":
        case "FunctionExpression":
          return false;
        case "ExportNamespaceSpecifier":
        case "ExportDefaultSpecifier":
          return false;
        case "ExportSpecifier":
          if (grandparent != null && grandparent.source) {
            return false;
          }
          return parent.local === node2;
        case "ImportDefaultSpecifier":
        case "ImportNamespaceSpecifier":
        case "ImportSpecifier":
          return false;
        case "ImportAttribute":
          return false;
        case "JSXAttribute":
          return false;
        case "ObjectPattern":
        case "ArrayPattern":
          return false;
        case "MetaProperty":
          return false;
        case "ObjectTypeProperty":
          return parent.key !== node2;
        case "TSEnumMember":
          return parent.id !== node2;
        case "TSPropertySignature":
          if (parent.key === node2) {
            return !!parent.computed;
          }
          return true;
      }
      return true;
    }
  }
});

// node_modules/@babel/types/lib/validators/isScope.js
var require_isScope = __commonJS({
  "node_modules/@babel/types/lib/validators/isScope.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isScope;
    var _generated = require_generated();
    function isScope(node2, parent) {
      if ((0, _generated.isBlockStatement)(node2) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
        return false;
      }
      if ((0, _generated.isPattern)(node2) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
        return true;
      }
      return (0, _generated.isScopable)(node2);
    }
  }
});

// node_modules/@babel/types/lib/validators/isSpecifierDefault.js
var require_isSpecifierDefault = __commonJS({
  "node_modules/@babel/types/lib/validators/isSpecifierDefault.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isSpecifierDefault;
    var _generated = require_generated();
    function isSpecifierDefault(specifier) {
      return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, {
        name: "default"
      });
    }
  }
});

// node_modules/@babel/types/lib/validators/isValidES3Identifier.js
var require_isValidES3Identifier = __commonJS({
  "node_modules/@babel/types/lib/validators/isValidES3Identifier.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isValidES3Identifier;
    var _isValidIdentifier = require_isValidIdentifier();
    var RESERVED_WORDS_ES3_ONLY = /* @__PURE__ */ new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
    function isValidES3Identifier(name2) {
      return (0, _isValidIdentifier.default)(name2) && !RESERVED_WORDS_ES3_ONLY.has(name2);
    }
  }
});

// node_modules/@babel/types/lib/validators/isVar.js
var require_isVar = __commonJS({
  "node_modules/@babel/types/lib/validators/isVar.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isVar;
    var _generated = require_generated();
    var _constants = require_constants();
    function isVar(node2) {
      return (0, _generated.isVariableDeclaration)(node2, {
        kind: "var"
      }) && !node2[_constants.BLOCK_SCOPED_SYMBOL];
    }
  }
});

// node_modules/@babel/types/lib/index.js
var require_lib3 = __commonJS({
  "node_modules/@babel/types/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    var _exportNames = {
      react: true,
      assertNode: true,
      createTypeAnnotationBasedOnTypeof: true,
      createUnionTypeAnnotation: true,
      createFlowUnionType: true,
      createTSUnionType: true,
      cloneNode: true,
      clone: true,
      cloneDeep: true,
      cloneDeepWithoutLoc: true,
      cloneWithoutLoc: true,
      addComment: true,
      addComments: true,
      inheritInnerComments: true,
      inheritLeadingComments: true,
      inheritsComments: true,
      inheritTrailingComments: true,
      removeComments: true,
      ensureBlock: true,
      toBindingIdentifierName: true,
      toBlock: true,
      toComputedKey: true,
      toExpression: true,
      toIdentifier: true,
      toKeyAlias: true,
      toSequenceExpression: true,
      toStatement: true,
      valueToNode: true,
      appendToMemberExpression: true,
      inherits: true,
      prependToMemberExpression: true,
      removeProperties: true,
      removePropertiesDeep: true,
      removeTypeDuplicates: true,
      getBindingIdentifiers: true,
      getOuterBindingIdentifiers: true,
      traverse: true,
      traverseFast: true,
      shallowEqual: true,
      is: true,
      isBinding: true,
      isBlockScoped: true,
      isImmutable: true,
      isLet: true,
      isNode: true,
      isNodesEquivalent: true,
      isPlaceholderType: true,
      isReferenced: true,
      isScope: true,
      isSpecifierDefault: true,
      isType: true,
      isValidES3Identifier: true,
      isValidIdentifier: true,
      isVar: true,
      matchesPattern: true,
      validate: true,
      buildMatchMemberExpression: true,
      __internal__deprecationWarning: true
    };
    Object.defineProperty(exports, "__internal__deprecationWarning", {
      enumerable: true,
      get: function() {
        return _deprecationWarning.default;
      }
    });
    Object.defineProperty(exports, "addComment", {
      enumerable: true,
      get: function() {
        return _addComment.default;
      }
    });
    Object.defineProperty(exports, "addComments", {
      enumerable: true,
      get: function() {
        return _addComments.default;
      }
    });
    Object.defineProperty(exports, "appendToMemberExpression", {
      enumerable: true,
      get: function() {
        return _appendToMemberExpression.default;
      }
    });
    Object.defineProperty(exports, "assertNode", {
      enumerable: true,
      get: function() {
        return _assertNode.default;
      }
    });
    Object.defineProperty(exports, "buildMatchMemberExpression", {
      enumerable: true,
      get: function() {
        return _buildMatchMemberExpression.default;
      }
    });
    Object.defineProperty(exports, "clone", {
      enumerable: true,
      get: function() {
        return _clone.default;
      }
    });
    Object.defineProperty(exports, "cloneDeep", {
      enumerable: true,
      get: function() {
        return _cloneDeep.default;
      }
    });
    Object.defineProperty(exports, "cloneDeepWithoutLoc", {
      enumerable: true,
      get: function() {
        return _cloneDeepWithoutLoc.default;
      }
    });
    Object.defineProperty(exports, "cloneNode", {
      enumerable: true,
      get: function() {
        return _cloneNode.default;
      }
    });
    Object.defineProperty(exports, "cloneWithoutLoc", {
      enumerable: true,
      get: function() {
        return _cloneWithoutLoc.default;
      }
    });
    Object.defineProperty(exports, "createFlowUnionType", {
      enumerable: true,
      get: function() {
        return _createFlowUnionType.default;
      }
    });
    Object.defineProperty(exports, "createTSUnionType", {
      enumerable: true,
      get: function() {
        return _createTSUnionType.default;
      }
    });
    Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
      enumerable: true,
      get: function() {
        return _createTypeAnnotationBasedOnTypeof.default;
      }
    });
    Object.defineProperty(exports, "createUnionTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _createFlowUnionType.default;
      }
    });
    Object.defineProperty(exports, "ensureBlock", {
      enumerable: true,
      get: function() {
        return _ensureBlock.default;
      }
    });
    Object.defineProperty(exports, "getBindingIdentifiers", {
      enumerable: true,
      get: function() {
        return _getBindingIdentifiers.default;
      }
    });
    Object.defineProperty(exports, "getOuterBindingIdentifiers", {
      enumerable: true,
      get: function() {
        return _getOuterBindingIdentifiers.default;
      }
    });
    Object.defineProperty(exports, "inheritInnerComments", {
      enumerable: true,
      get: function() {
        return _inheritInnerComments.default;
      }
    });
    Object.defineProperty(exports, "inheritLeadingComments", {
      enumerable: true,
      get: function() {
        return _inheritLeadingComments.default;
      }
    });
    Object.defineProperty(exports, "inheritTrailingComments", {
      enumerable: true,
      get: function() {
        return _inheritTrailingComments.default;
      }
    });
    Object.defineProperty(exports, "inherits", {
      enumerable: true,
      get: function() {
        return _inherits.default;
      }
    });
    Object.defineProperty(exports, "inheritsComments", {
      enumerable: true,
      get: function() {
        return _inheritsComments.default;
      }
    });
    Object.defineProperty(exports, "is", {
      enumerable: true,
      get: function() {
        return _is.default;
      }
    });
    Object.defineProperty(exports, "isBinding", {
      enumerable: true,
      get: function() {
        return _isBinding.default;
      }
    });
    Object.defineProperty(exports, "isBlockScoped", {
      enumerable: true,
      get: function() {
        return _isBlockScoped.default;
      }
    });
    Object.defineProperty(exports, "isImmutable", {
      enumerable: true,
      get: function() {
        return _isImmutable.default;
      }
    });
    Object.defineProperty(exports, "isLet", {
      enumerable: true,
      get: function() {
        return _isLet.default;
      }
    });
    Object.defineProperty(exports, "isNode", {
      enumerable: true,
      get: function() {
        return _isNode.default;
      }
    });
    Object.defineProperty(exports, "isNodesEquivalent", {
      enumerable: true,
      get: function() {
        return _isNodesEquivalent.default;
      }
    });
    Object.defineProperty(exports, "isPlaceholderType", {
      enumerable: true,
      get: function() {
        return _isPlaceholderType.default;
      }
    });
    Object.defineProperty(exports, "isReferenced", {
      enumerable: true,
      get: function() {
        return _isReferenced.default;
      }
    });
    Object.defineProperty(exports, "isScope", {
      enumerable: true,
      get: function() {
        return _isScope.default;
      }
    });
    Object.defineProperty(exports, "isSpecifierDefault", {
      enumerable: true,
      get: function() {
        return _isSpecifierDefault.default;
      }
    });
    Object.defineProperty(exports, "isType", {
      enumerable: true,
      get: function() {
        return _isType.default;
      }
    });
    Object.defineProperty(exports, "isValidES3Identifier", {
      enumerable: true,
      get: function() {
        return _isValidES3Identifier.default;
      }
    });
    Object.defineProperty(exports, "isValidIdentifier", {
      enumerable: true,
      get: function() {
        return _isValidIdentifier.default;
      }
    });
    Object.defineProperty(exports, "isVar", {
      enumerable: true,
      get: function() {
        return _isVar.default;
      }
    });
    Object.defineProperty(exports, "matchesPattern", {
      enumerable: true,
      get: function() {
        return _matchesPattern.default;
      }
    });
    Object.defineProperty(exports, "prependToMemberExpression", {
      enumerable: true,
      get: function() {
        return _prependToMemberExpression.default;
      }
    });
    exports.react = void 0;
    Object.defineProperty(exports, "removeComments", {
      enumerable: true,
      get: function() {
        return _removeComments.default;
      }
    });
    Object.defineProperty(exports, "removeProperties", {
      enumerable: true,
      get: function() {
        return _removeProperties.default;
      }
    });
    Object.defineProperty(exports, "removePropertiesDeep", {
      enumerable: true,
      get: function() {
        return _removePropertiesDeep.default;
      }
    });
    Object.defineProperty(exports, "removeTypeDuplicates", {
      enumerable: true,
      get: function() {
        return _removeTypeDuplicates.default;
      }
    });
    Object.defineProperty(exports, "shallowEqual", {
      enumerable: true,
      get: function() {
        return _shallowEqual.default;
      }
    });
    Object.defineProperty(exports, "toBindingIdentifierName", {
      enumerable: true,
      get: function() {
        return _toBindingIdentifierName.default;
      }
    });
    Object.defineProperty(exports, "toBlock", {
      enumerable: true,
      get: function() {
        return _toBlock.default;
      }
    });
    Object.defineProperty(exports, "toComputedKey", {
      enumerable: true,
      get: function() {
        return _toComputedKey.default;
      }
    });
    Object.defineProperty(exports, "toExpression", {
      enumerable: true,
      get: function() {
        return _toExpression.default;
      }
    });
    Object.defineProperty(exports, "toIdentifier", {
      enumerable: true,
      get: function() {
        return _toIdentifier.default;
      }
    });
    Object.defineProperty(exports, "toKeyAlias", {
      enumerable: true,
      get: function() {
        return _toKeyAlias.default;
      }
    });
    Object.defineProperty(exports, "toSequenceExpression", {
      enumerable: true,
      get: function() {
        return _toSequenceExpression.default;
      }
    });
    Object.defineProperty(exports, "toStatement", {
      enumerable: true,
      get: function() {
        return _toStatement.default;
      }
    });
    Object.defineProperty(exports, "traverse", {
      enumerable: true,
      get: function() {
        return _traverse.default;
      }
    });
    Object.defineProperty(exports, "traverseFast", {
      enumerable: true,
      get: function() {
        return _traverseFast.default;
      }
    });
    Object.defineProperty(exports, "validate", {
      enumerable: true,
      get: function() {
        return _validate.default;
      }
    });
    Object.defineProperty(exports, "valueToNode", {
      enumerable: true,
      get: function() {
        return _valueToNode.default;
      }
    });
    var _isReactComponent = require_isReactComponent();
    var _isCompatTag = require_isCompatTag();
    var _buildChildren = require_buildChildren();
    var _assertNode = require_assertNode();
    var _generated = require_generated3();
    Object.keys(_generated).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _generated[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _generated[key2];
        }
      });
    });
    var _createTypeAnnotationBasedOnTypeof = require_createTypeAnnotationBasedOnTypeof();
    var _createFlowUnionType = require_createFlowUnionType();
    var _createTSUnionType = require_createTSUnionType();
    var _generated2 = require_generated2();
    Object.keys(_generated2).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _generated2[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _generated2[key2];
        }
      });
    });
    var _uppercase = require_uppercase();
    Object.keys(_uppercase).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _uppercase[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _uppercase[key2];
        }
      });
    });
    var _cloneNode = require_cloneNode();
    var _clone = require_clone();
    var _cloneDeep = require_cloneDeep();
    var _cloneDeepWithoutLoc = require_cloneDeepWithoutLoc();
    var _cloneWithoutLoc = require_cloneWithoutLoc();
    var _addComment = require_addComment();
    var _addComments = require_addComments();
    var _inheritInnerComments = require_inheritInnerComments();
    var _inheritLeadingComments = require_inheritLeadingComments();
    var _inheritsComments = require_inheritsComments();
    var _inheritTrailingComments = require_inheritTrailingComments();
    var _removeComments = require_removeComments();
    var _generated3 = require_generated4();
    Object.keys(_generated3).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _generated3[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _generated3[key2];
        }
      });
    });
    var _constants = require_constants();
    Object.keys(_constants).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _constants[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _constants[key2];
        }
      });
    });
    var _ensureBlock = require_ensureBlock();
    var _toBindingIdentifierName = require_toBindingIdentifierName();
    var _toBlock = require_toBlock();
    var _toComputedKey = require_toComputedKey();
    var _toExpression = require_toExpression();
    var _toIdentifier = require_toIdentifier();
    var _toKeyAlias = require_toKeyAlias();
    var _toSequenceExpression = require_toSequenceExpression();
    var _toStatement = require_toStatement();
    var _valueToNode = require_valueToNode();
    var _definitions = require_definitions();
    Object.keys(_definitions).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _definitions[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _definitions[key2];
        }
      });
    });
    var _appendToMemberExpression = require_appendToMemberExpression();
    var _inherits = require_inherits();
    var _prependToMemberExpression = require_prependToMemberExpression();
    var _removeProperties = require_removeProperties();
    var _removePropertiesDeep = require_removePropertiesDeep();
    var _removeTypeDuplicates = require_removeTypeDuplicates();
    var _getBindingIdentifiers = require_getBindingIdentifiers();
    var _getOuterBindingIdentifiers = require_getOuterBindingIdentifiers();
    var _traverse = require_traverse();
    Object.keys(_traverse).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _traverse[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _traverse[key2];
        }
      });
    });
    var _traverseFast = require_traverseFast();
    var _shallowEqual = require_shallowEqual();
    var _is = require_is();
    var _isBinding = require_isBinding();
    var _isBlockScoped = require_isBlockScoped();
    var _isImmutable = require_isImmutable();
    var _isLet = require_isLet();
    var _isNode = require_isNode();
    var _isNodesEquivalent = require_isNodesEquivalent();
    var _isPlaceholderType = require_isPlaceholderType();
    var _isReferenced = require_isReferenced();
    var _isScope = require_isScope();
    var _isSpecifierDefault = require_isSpecifierDefault();
    var _isType = require_isType();
    var _isValidES3Identifier = require_isValidES3Identifier();
    var _isValidIdentifier = require_isValidIdentifier();
    var _isVar = require_isVar();
    var _matchesPattern = require_matchesPattern();
    var _validate = require_validate();
    var _buildMatchMemberExpression = require_buildMatchMemberExpression();
    var _generated4 = require_generated();
    Object.keys(_generated4).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (Object.prototype.hasOwnProperty.call(_exportNames, key2))
        return;
      if (key2 in exports && exports[key2] === _generated4[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _generated4[key2];
        }
      });
    });
    var _deprecationWarning = require_deprecationWarning();
    var react = {
      isReactComponent: _isReactComponent.default,
      isCompatTag: _isCompatTag.default,
      buildChildren: _buildChildren.default
    };
    exports.react = react;
  }
});

// node_modules/@babel/generator/lib/node/whitespace.js
var require_whitespace = __commonJS({
  "node_modules/@babel/generator/lib/node/whitespace.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.nodes = void 0;
    var _t = require_lib3();
    var {
      FLIPPED_ALIAS_KEYS,
      isArrayExpression,
      isAssignmentExpression,
      isBinary,
      isBlockStatement,
      isCallExpression: isCallExpression2,
      isFunction,
      isIdentifier: isIdentifier3,
      isLiteral,
      isMemberExpression: isMemberExpression2,
      isObjectExpression: isObjectExpression2,
      isOptionalCallExpression,
      isOptionalMemberExpression,
      isStringLiteral: isStringLiteral2
    } = _t;
    function crawlInternal(node2, state) {
      if (!node2)
        return state;
      if (isMemberExpression2(node2) || isOptionalMemberExpression(node2)) {
        crawlInternal(node2.object, state);
        if (node2.computed)
          crawlInternal(node2.property, state);
      } else if (isBinary(node2) || isAssignmentExpression(node2)) {
        crawlInternal(node2.left, state);
        crawlInternal(node2.right, state);
      } else if (isCallExpression2(node2) || isOptionalCallExpression(node2)) {
        state.hasCall = true;
        crawlInternal(node2.callee, state);
      } else if (isFunction(node2)) {
        state.hasFunction = true;
      } else if (isIdentifier3(node2)) {
        state.hasHelper = state.hasHelper || node2.callee && isHelper(node2.callee);
      }
      return state;
    }
    function crawl(node2) {
      return crawlInternal(node2, {
        hasCall: false,
        hasFunction: false,
        hasHelper: false
      });
    }
    function isHelper(node2) {
      if (!node2)
        return false;
      if (isMemberExpression2(node2)) {
        return isHelper(node2.object) || isHelper(node2.property);
      } else if (isIdentifier3(node2)) {
        return node2.name === "require" || node2.name.charCodeAt(0) === 95;
      } else if (isCallExpression2(node2)) {
        return isHelper(node2.callee);
      } else if (isBinary(node2) || isAssignmentExpression(node2)) {
        return isIdentifier3(node2.left) && isHelper(node2.left) || isHelper(node2.right);
      } else {
        return false;
      }
    }
    function isType(node2) {
      return isLiteral(node2) || isObjectExpression2(node2) || isArrayExpression(node2) || isIdentifier3(node2) || isMemberExpression2(node2);
    }
    var nodes = {
      AssignmentExpression(node2) {
        const state = crawl(node2.right);
        if (state.hasCall && state.hasHelper || state.hasFunction) {
          return state.hasFunction ? 1 | 2 : 2;
        }
      },
      SwitchCase(node2, parent) {
        return (!!node2.consequent.length || parent.cases[0] === node2 ? 1 : 0) | (!node2.consequent.length && parent.cases[parent.cases.length - 1] === node2 ? 2 : 0);
      },
      LogicalExpression(node2) {
        if (isFunction(node2.left) || isFunction(node2.right)) {
          return 2;
        }
      },
      Literal(node2) {
        if (isStringLiteral2(node2) && node2.value === "use strict") {
          return 2;
        }
      },
      CallExpression(node2) {
        if (isFunction(node2.callee) || isHelper(node2)) {
          return 1 | 2;
        }
      },
      OptionalCallExpression(node2) {
        if (isFunction(node2.callee)) {
          return 1 | 2;
        }
      },
      VariableDeclaration(node2) {
        for (let i = 0; i < node2.declarations.length; i++) {
          const declar = node2.declarations[i];
          let enabled = isHelper(declar.id) && !isType(declar.init);
          if (!enabled && declar.init) {
            const state = crawl(declar.init);
            enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
          }
          if (enabled) {
            return 1 | 2;
          }
        }
      },
      IfStatement(node2) {
        if (isBlockStatement(node2.consequent)) {
          return 1 | 2;
        }
      }
    };
    exports.nodes = nodes;
    nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function(node2, parent) {
      if (parent.properties[0] === node2) {
        return 1;
      }
    };
    nodes.ObjectTypeCallProperty = function(node2, parent) {
      var _parent$properties;
      if (parent.callProperties[0] === node2 && !((_parent$properties = parent.properties) != null && _parent$properties.length)) {
        return 1;
      }
    };
    nodes.ObjectTypeIndexer = function(node2, parent) {
      var _parent$properties2, _parent$callPropertie;
      if (parent.indexers[0] === node2 && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) {
        return 1;
      }
    };
    nodes.ObjectTypeInternalSlot = function(node2, parent) {
      var _parent$properties3, _parent$callPropertie2, _parent$indexers;
      if (parent.internalSlots[0] === node2 && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) {
        return 1;
      }
    };
    [["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function([type, amounts]) {
      [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function(type2) {
        const ret = amounts ? 1 | 2 : 0;
        nodes[type2] = () => ret;
      });
    });
  }
});

// node_modules/@babel/generator/lib/node/parentheses.js
var require_parentheses = __commonJS({
  "node_modules/@babel/generator/lib/node/parentheses.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ArrowFunctionExpression = ArrowFunctionExpression;
    exports.AssignmentExpression = AssignmentExpression;
    exports.Binary = Binary;
    exports.BinaryExpression = BinaryExpression2;
    exports.ClassExpression = ClassExpression;
    exports.ConditionalExpression = ConditionalExpression;
    exports.DoExpression = DoExpression;
    exports.FunctionExpression = FunctionExpression;
    exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
    exports.Identifier = Identifier;
    exports.LogicalExpression = LogicalExpression;
    exports.NullableTypeAnnotation = NullableTypeAnnotation;
    exports.ObjectExpression = ObjectExpression;
    exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
    exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
    exports.SequenceExpression = SequenceExpression;
    exports.TSTypeAssertion = exports.TSSatisfiesExpression = exports.TSAsExpression = TSAsExpression;
    exports.TSInferType = TSInferType;
    exports.TSInstantiationExpression = TSInstantiationExpression;
    exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
    exports.UnaryLike = UnaryLike;
    exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
    exports.UpdateExpression = UpdateExpression;
    exports.AwaitExpression = exports.YieldExpression = YieldExpression;
    var _t = require_lib3();
    var {
      isArrayTypeAnnotation,
      isArrowFunctionExpression: isArrowFunctionExpression2,
      isAssignmentExpression,
      isAwaitExpression,
      isBinary,
      isBinaryExpression,
      isUpdateExpression,
      isCallExpression: isCallExpression2,
      isClass,
      isClassExpression,
      isConditional,
      isConditionalExpression,
      isExportDeclaration,
      isExportDefaultDeclaration,
      isExpressionStatement: isExpressionStatement2,
      isFor,
      isForInStatement,
      isForOfStatement,
      isForStatement,
      isFunctionExpression,
      isIfStatement,
      isIndexedAccessType,
      isIntersectionTypeAnnotation,
      isLogicalExpression,
      isMemberExpression: isMemberExpression2,
      isNewExpression,
      isNullableTypeAnnotation,
      isObjectPattern,
      isOptionalCallExpression,
      isOptionalMemberExpression,
      isReturnStatement,
      isSequenceExpression,
      isSwitchStatement,
      isTSArrayType,
      isTSAsExpression,
      isTSInstantiationExpression,
      isTSIntersectionType,
      isTSNonNullExpression,
      isTSOptionalType,
      isTSRestType,
      isTSTypeAssertion,
      isTSUnionType,
      isTaggedTemplateExpression,
      isThrowStatement,
      isTypeAnnotation,
      isUnaryLike,
      isUnionTypeAnnotation,
      isVariableDeclarator: isVariableDeclarator2,
      isWhileStatement,
      isYieldExpression,
      isTSSatisfiesExpression
    } = _t;
    var PRECEDENCE = {
      "||": 0,
      "??": 0,
      "|>": 0,
      "&&": 1,
      "|": 2,
      "^": 3,
      "&": 4,
      "==": 5,
      "===": 5,
      "!=": 5,
      "!==": 5,
      "<": 6,
      ">": 6,
      "<=": 6,
      ">=": 6,
      in: 6,
      instanceof: 6,
      ">>": 7,
      "<<": 7,
      ">>>": 7,
      "+": 8,
      "-": 8,
      "*": 9,
      "/": 9,
      "%": 9,
      "**": 10
    };
    function isTSTypeExpression(node2) {
      return isTSAsExpression(node2) || isTSSatisfiesExpression(node2) || isTSTypeAssertion(node2);
    }
    var isClassExtendsClause = (node2, parent) => isClass(parent, {
      superClass: node2
    });
    var hasPostfixPart = (node2, parent) => (isMemberExpression2(parent) || isOptionalMemberExpression(parent)) && parent.object === node2 || (isCallExpression2(parent) || isOptionalCallExpression(parent) || isNewExpression(parent)) && parent.callee === node2 || isTaggedTemplateExpression(parent) && parent.tag === node2 || isTSNonNullExpression(parent);
    function NullableTypeAnnotation(node2, parent) {
      return isArrayTypeAnnotation(parent);
    }
    function FunctionTypeAnnotation(node2, parent, printStack) {
      if (printStack.length < 3)
        return;
      return isUnionTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isArrayTypeAnnotation(parent) || isTypeAnnotation(parent) && isArrowFunctionExpression2(printStack[printStack.length - 3]);
    }
    function UpdateExpression(node2, parent) {
      return hasPostfixPart(node2, parent) || isClassExtendsClause(node2, parent);
    }
    function ObjectExpression(node2, parent, printStack) {
      return isFirstInContext(printStack, 1 | 2);
    }
    function DoExpression(node2, parent, printStack) {
      return !node2.async && isFirstInContext(printStack, 1);
    }
    function Binary(node2, parent) {
      if (node2.operator === "**" && isBinaryExpression(parent, {
        operator: "**"
      })) {
        return parent.left === node2;
      }
      if (isClassExtendsClause(node2, parent)) {
        return true;
      }
      if (hasPostfixPart(node2, parent) || isUnaryLike(parent) || isAwaitExpression(parent)) {
        return true;
      }
      if (isBinary(parent)) {
        const parentOp = parent.operator;
        const parentPos = PRECEDENCE[parentOp];
        const nodeOp = node2.operator;
        const nodePos = PRECEDENCE[nodeOp];
        if (parentPos === nodePos && parent.right === node2 && !isLogicalExpression(parent) || parentPos > nodePos) {
          return true;
        }
      }
    }
    function UnionTypeAnnotation(node2, parent) {
      return isArrayTypeAnnotation(parent) || isNullableTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isUnionTypeAnnotation(parent);
    }
    function OptionalIndexedAccessType(node2, parent) {
      return isIndexedAccessType(parent, {
        objectType: node2
      });
    }
    function TSAsExpression() {
      return true;
    }
    function TSUnionType(node2, parent) {
      return isTSArrayType(parent) || isTSOptionalType(parent) || isTSIntersectionType(parent) || isTSUnionType(parent) || isTSRestType(parent);
    }
    function TSInferType(node2, parent) {
      return isTSArrayType(parent) || isTSOptionalType(parent);
    }
    function TSInstantiationExpression(node2, parent) {
      return (isCallExpression2(parent) || isOptionalCallExpression(parent) || isNewExpression(parent) || isTSInstantiationExpression(parent)) && !!parent.typeParameters;
    }
    function BinaryExpression2(node2, parent) {
      return node2.operator === "in" && (isVariableDeclarator2(parent) || isFor(parent));
    }
    function SequenceExpression(node2, parent) {
      if (isForStatement(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement(parent) && parent.test === node2 || isWhileStatement(parent) && parent.test === node2 || isForInStatement(parent) && parent.right === node2 || isSwitchStatement(parent) && parent.discriminant === node2 || isExpressionStatement2(parent) && parent.expression === node2) {
        return false;
      }
      return true;
    }
    function YieldExpression(node2, parent) {
      return isBinary(parent) || isUnaryLike(parent) || hasPostfixPart(node2, parent) || isAwaitExpression(parent) && isYieldExpression(node2) || isConditionalExpression(parent) && node2 === parent.test || isClassExtendsClause(node2, parent);
    }
    function ClassExpression(node2, parent, printStack) {
      return isFirstInContext(printStack, 1 | 4);
    }
    function UnaryLike(node2, parent) {
      return hasPostfixPart(node2, parent) || isBinaryExpression(parent, {
        operator: "**",
        left: node2
      }) || isClassExtendsClause(node2, parent);
    }
    function FunctionExpression(node2, parent, printStack) {
      return isFirstInContext(printStack, 1 | 4);
    }
    function ArrowFunctionExpression(node2, parent) {
      return isExportDeclaration(parent) || ConditionalExpression(node2, parent);
    }
    function ConditionalExpression(node2, parent) {
      if (isUnaryLike(parent) || isBinary(parent) || isConditionalExpression(parent, {
        test: node2
      }) || isAwaitExpression(parent) || isTSTypeExpression(parent)) {
        return true;
      }
      return UnaryLike(node2, parent);
    }
    function OptionalMemberExpression(node2, parent) {
      return isCallExpression2(parent, {
        callee: node2
      }) || isMemberExpression2(parent, {
        object: node2
      });
    }
    function AssignmentExpression(node2, parent) {
      if (isObjectPattern(node2.left)) {
        return true;
      } else {
        return ConditionalExpression(node2, parent);
      }
    }
    function LogicalExpression(node2, parent) {
      if (isTSTypeExpression(parent))
        return true;
      switch (node2.operator) {
        case "||":
          if (!isLogicalExpression(parent))
            return false;
          return parent.operator === "??" || parent.operator === "&&";
        case "&&":
          return isLogicalExpression(parent, {
            operator: "??"
          });
        case "??":
          return isLogicalExpression(parent) && parent.operator !== "??";
      }
    }
    function Identifier(node2, parent, printStack) {
      var _node$extra;
      if ((_node$extra = node2.extra) != null && _node$extra.parenthesized && isAssignmentExpression(parent, {
        left: node2
      }) && (isFunctionExpression(parent.right) || isClassExpression(parent.right)) && parent.right.id == null) {
        return true;
      }
      if (node2.name === "let") {
        const isFollowedByBracket = isMemberExpression2(parent, {
          object: node2,
          computed: true
        }) || isOptionalMemberExpression(parent, {
          object: node2,
          computed: true,
          optional: false
        });
        return isFirstInContext(printStack, isFollowedByBracket ? 1 | 8 | 16 | 32 : 32);
      }
      return node2.name === "async" && isForOfStatement(parent) && node2 === parent.left;
    }
    function isFirstInContext(printStack, checkParam) {
      const expressionStatement = checkParam & 1;
      const arrowBody = checkParam & 2;
      const exportDefault = checkParam & 4;
      const forHead = checkParam & 8;
      const forInHead = checkParam & 16;
      const forOfHead = checkParam & 32;
      let i = printStack.length - 1;
      if (i <= 0)
        return;
      let node2 = printStack[i];
      i--;
      let parent = printStack[i];
      while (i >= 0) {
        if (expressionStatement && isExpressionStatement2(parent, {
          expression: node2
        }) || exportDefault && isExportDefaultDeclaration(parent, {
          declaration: node2
        }) || arrowBody && isArrowFunctionExpression2(parent, {
          body: node2
        }) || forHead && isForStatement(parent, {
          init: node2
        }) || forInHead && isForInStatement(parent, {
          left: node2
        }) || forOfHead && isForOfStatement(parent, {
          left: node2
        })) {
          return true;
        }
        if (i > 0 && (hasPostfixPart(node2, parent) && !isNewExpression(parent) || isSequenceExpression(parent) && parent.expressions[0] === node2 || isUpdateExpression(parent) && !parent.prefix || isConditional(parent, {
          test: node2
        }) || isBinary(parent, {
          left: node2
        }) || isAssignmentExpression(parent, {
          left: node2
        }))) {
          node2 = parent;
          i--;
          parent = printStack[i];
        } else {
          return false;
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/generator/lib/node/index.js
var require_node = __commonJS({
  "node_modules/@babel/generator/lib/node/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.needsParens = needsParens;
    exports.needsWhitespace = needsWhitespace;
    exports.needsWhitespaceAfter = needsWhitespaceAfter;
    exports.needsWhitespaceBefore = needsWhitespaceBefore;
    var whitespace2 = require_whitespace();
    var parens = require_parentheses();
    var _t = require_lib3();
    var {
      FLIPPED_ALIAS_KEYS,
      isCallExpression: isCallExpression2,
      isExpressionStatement: isExpressionStatement2,
      isMemberExpression: isMemberExpression2,
      isNewExpression
    } = _t;
    function expandAliases(obj) {
      const newObj = {};
      function add(type, func) {
        const fn = newObj[type];
        newObj[type] = fn ? function(node2, parent, stack2) {
          const result = fn(node2, parent, stack2);
          return result == null ? func(node2, parent, stack2) : result;
        } : func;
      }
      for (const type of Object.keys(obj)) {
        const aliases = FLIPPED_ALIAS_KEYS[type];
        if (aliases) {
          for (const alias of aliases) {
            add(alias, obj[type]);
          }
        } else {
          add(type, obj[type]);
        }
      }
      return newObj;
    }
    var expandedParens = expandAliases(parens);
    var expandedWhitespaceNodes = expandAliases(whitespace2.nodes);
    function find2(obj, node2, parent, printStack) {
      const fn = obj[node2.type];
      return fn ? fn(node2, parent, printStack) : null;
    }
    function isOrHasCallExpression(node2) {
      if (isCallExpression2(node2)) {
        return true;
      }
      return isMemberExpression2(node2) && isOrHasCallExpression(node2.object);
    }
    function needsWhitespace(node2, parent, type) {
      if (!node2)
        return false;
      if (isExpressionStatement2(node2)) {
        node2 = node2.expression;
      }
      const flag = find2(expandedWhitespaceNodes, node2, parent);
      if (typeof flag === "number") {
        return (flag & type) !== 0;
      }
      return false;
    }
    function needsWhitespaceBefore(node2, parent) {
      return needsWhitespace(node2, parent, 1);
    }
    function needsWhitespaceAfter(node2, parent) {
      return needsWhitespace(node2, parent, 2);
    }
    function needsParens(node2, parent, printStack) {
      if (!parent)
        return false;
      if (isNewExpression(parent) && parent.callee === node2) {
        if (isOrHasCallExpression(node2))
          return true;
      }
      return find2(expandedParens, node2, parent, printStack);
    }
  }
});

// node_modules/@babel/generator/lib/generators/template-literals.js
var require_template_literals = __commonJS({
  "node_modules/@babel/generator/lib/generators/template-literals.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.TaggedTemplateExpression = TaggedTemplateExpression;
    exports.TemplateElement = TemplateElement;
    exports.TemplateLiteral = TemplateLiteral;
    function TaggedTemplateExpression(node2) {
      this.print(node2.tag, node2);
      this.print(node2.typeParameters, node2);
      this.print(node2.quasi, node2);
    }
    function TemplateElement(node2, parent) {
      const isFirst = parent.quasis[0] === node2;
      const isLast = parent.quasis[parent.quasis.length - 1] === node2;
      const value2 = (isFirst ? "`" : "}") + node2.value.raw + (isLast ? "`" : "${");
      this.token(value2, true);
    }
    function TemplateLiteral(node2) {
      const quasis = node2.quasis;
      for (let i = 0; i < quasis.length; i++) {
        this.print(quasis[i], node2);
        if (i + 1 < quasis.length) {
          this.print(node2.expressions[i], node2);
        }
      }
    }
  }
});

// node_modules/@babel/generator/lib/generators/expressions.js
var require_expressions = __commonJS({
  "node_modules/@babel/generator/lib/generators/expressions.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
    exports.AssignmentPattern = AssignmentPattern;
    exports.AwaitExpression = AwaitExpression;
    exports.BindExpression = BindExpression;
    exports.CallExpression = CallExpression;
    exports.ConditionalExpression = ConditionalExpression;
    exports.Decorator = Decorator;
    exports.DoExpression = DoExpression;
    exports.EmptyStatement = EmptyStatement;
    exports.ExpressionStatement = ExpressionStatement;
    exports.Import = Import;
    exports.MemberExpression = MemberExpression;
    exports.MetaProperty = MetaProperty;
    exports.ModuleExpression = ModuleExpression;
    exports.NewExpression = NewExpression;
    exports.OptionalCallExpression = OptionalCallExpression;
    exports.OptionalMemberExpression = OptionalMemberExpression;
    exports.ParenthesizedExpression = ParenthesizedExpression;
    exports.PrivateName = PrivateName;
    exports.SequenceExpression = SequenceExpression;
    exports.Super = Super;
    exports.ThisExpression = ThisExpression;
    exports.UnaryExpression = UnaryExpression;
    exports.UpdateExpression = UpdateExpression;
    exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
    exports.YieldExpression = YieldExpression;
    exports._shouldPrintDecoratorsBeforeExport = _shouldPrintDecoratorsBeforeExport;
    var _t = require_lib3();
    var n = require_node();
    var {
      isCallExpression: isCallExpression2,
      isLiteral,
      isMemberExpression: isMemberExpression2,
      isNewExpression
    } = _t;
    function UnaryExpression(node2) {
      if (node2.operator === "void" || node2.operator === "delete" || node2.operator === "typeof" || node2.operator === "throw") {
        this.word(node2.operator);
        this.space();
      } else {
        this.token(node2.operator);
      }
      this.print(node2.argument, node2);
    }
    function DoExpression(node2) {
      if (node2.async) {
        this.word("async", true);
        this.space();
      }
      this.word("do");
      this.space();
      this.print(node2.body, node2);
    }
    function ParenthesizedExpression(node2) {
      this.tokenChar(40);
      this.print(node2.expression, node2);
      this.tokenChar(41);
    }
    function UpdateExpression(node2) {
      if (node2.prefix) {
        this.token(node2.operator);
        this.print(node2.argument, node2);
      } else {
        this.printTerminatorless(node2.argument, node2, true);
        this.token(node2.operator);
      }
    }
    function ConditionalExpression(node2) {
      this.print(node2.test, node2);
      this.space();
      this.tokenChar(63);
      this.space();
      this.print(node2.consequent, node2);
      this.space();
      this.tokenChar(58);
      this.space();
      this.print(node2.alternate, node2);
    }
    function NewExpression(node2, parent) {
      this.word("new");
      this.space();
      this.print(node2.callee, node2);
      if (this.format.minified && node2.arguments.length === 0 && !node2.optional && !isCallExpression2(parent, {
        callee: node2
      }) && !isMemberExpression2(parent) && !isNewExpression(parent)) {
        return;
      }
      this.print(node2.typeArguments, node2);
      this.print(node2.typeParameters, node2);
      if (node2.optional) {
        this.token("?.");
      }
      this.tokenChar(40);
      this.printList(node2.arguments, node2);
      this.tokenChar(41);
    }
    function SequenceExpression(node2) {
      this.printList(node2.expressions, node2);
    }
    function ThisExpression() {
      this.word("this");
    }
    function Super() {
      this.word("super");
    }
    function isDecoratorMemberExpression(node2) {
      switch (node2.type) {
        case "Identifier":
          return true;
        case "MemberExpression":
          return !node2.computed && node2.property.type === "Identifier" && isDecoratorMemberExpression(node2.object);
        default:
          return false;
      }
    }
    function shouldParenthesizeDecoratorExpression(node2) {
      if (node2.type === "ParenthesizedExpression") {
        return false;
      }
      return !isDecoratorMemberExpression(node2.type === "CallExpression" ? node2.callee : node2);
    }
    function _shouldPrintDecoratorsBeforeExport(node2) {
      if (typeof this.format.decoratorsBeforeExport === "boolean") {
        return this.format.decoratorsBeforeExport;
      }
      return typeof node2.start === "number" && node2.start === node2.declaration.start;
    }
    function Decorator(node2) {
      this.tokenChar(64);
      const {
        expression
      } = node2;
      if (shouldParenthesizeDecoratorExpression(expression)) {
        this.tokenChar(40);
        this.print(expression, node2);
        this.tokenChar(41);
      } else {
        this.print(expression, node2);
      }
      this.newline();
    }
    function OptionalMemberExpression(node2) {
      this.print(node2.object, node2);
      if (!node2.computed && isMemberExpression2(node2.property)) {
        throw new TypeError("Got a MemberExpression for MemberExpression property");
      }
      let computed = node2.computed;
      if (isLiteral(node2.property) && typeof node2.property.value === "number") {
        computed = true;
      }
      if (node2.optional) {
        this.token("?.");
      }
      if (computed) {
        this.tokenChar(91);
        this.print(node2.property, node2);
        this.tokenChar(93);
      } else {
        if (!node2.optional) {
          this.tokenChar(46);
        }
        this.print(node2.property, node2);
      }
    }
    function OptionalCallExpression(node2) {
      this.print(node2.callee, node2);
      this.print(node2.typeParameters, node2);
      if (node2.optional) {
        this.token("?.");
      }
      this.print(node2.typeArguments, node2);
      this.tokenChar(40);
      this.printList(node2.arguments, node2);
      this.tokenChar(41);
    }
    function CallExpression(node2) {
      this.print(node2.callee, node2);
      this.print(node2.typeArguments, node2);
      this.print(node2.typeParameters, node2);
      this.tokenChar(40);
      this.printList(node2.arguments, node2);
      this.tokenChar(41);
    }
    function Import() {
      this.word("import");
    }
    function AwaitExpression(node2) {
      this.word("await");
      if (node2.argument) {
        this.space();
        this.printTerminatorless(node2.argument, node2, false);
      }
    }
    function YieldExpression(node2) {
      this.word("yield", true);
      if (node2.delegate) {
        this.tokenChar(42);
        if (node2.argument) {
          this.space();
          this.print(node2.argument, node2);
        }
      } else {
        if (node2.argument) {
          this.space();
          this.printTerminatorless(node2.argument, node2, false);
        }
      }
    }
    function EmptyStatement() {
      this.semicolon(true);
    }
    function ExpressionStatement(node2) {
      this.print(node2.expression, node2);
      this.semicolon();
    }
    function AssignmentPattern(node2) {
      this.print(node2.left, node2);
      if (node2.left.optional)
        this.tokenChar(63);
      this.print(node2.left.typeAnnotation, node2);
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node2.right, node2);
    }
    function AssignmentExpression(node2, parent) {
      const parens = this.inForStatementInitCounter && node2.operator === "in" && !n.needsParens(node2, parent);
      if (parens) {
        this.tokenChar(40);
      }
      this.print(node2.left, node2);
      this.space();
      if (node2.operator === "in" || node2.operator === "instanceof") {
        this.word(node2.operator);
      } else {
        this.token(node2.operator);
      }
      this.space();
      this.print(node2.right, node2);
      if (parens) {
        this.tokenChar(41);
      }
    }
    function BindExpression(node2) {
      this.print(node2.object, node2);
      this.token("::");
      this.print(node2.callee, node2);
    }
    function MemberExpression(node2) {
      this.print(node2.object, node2);
      if (!node2.computed && isMemberExpression2(node2.property)) {
        throw new TypeError("Got a MemberExpression for MemberExpression property");
      }
      let computed = node2.computed;
      if (isLiteral(node2.property) && typeof node2.property.value === "number") {
        computed = true;
      }
      if (computed) {
        this.tokenChar(91);
        this.print(node2.property, node2);
        this.tokenChar(93);
      } else {
        this.tokenChar(46);
        this.print(node2.property, node2);
      }
    }
    function MetaProperty(node2) {
      this.print(node2.meta, node2);
      this.tokenChar(46);
      this.print(node2.property, node2);
    }
    function PrivateName(node2) {
      this.tokenChar(35);
      this.print(node2.id, node2);
    }
    function V8IntrinsicIdentifier(node2) {
      this.tokenChar(37);
      this.word(node2.name);
    }
    function ModuleExpression(node2) {
      this.word("module", true);
      this.space();
      this.tokenChar(123);
      this.indent();
      const {
        body
      } = node2;
      if (body.body.length || body.directives.length) {
        this.newline();
      }
      this.print(body, node2);
      this.dedent();
      this.sourceWithOffset("end", node2.loc, 0, -1);
      this.rightBrace();
    }
  }
});

// node_modules/@babel/generator/lib/generators/statements.js
var require_statements = __commonJS({
  "node_modules/@babel/generator/lib/generators/statements.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.BreakStatement = BreakStatement;
    exports.CatchClause = CatchClause;
    exports.ContinueStatement = ContinueStatement;
    exports.DebuggerStatement = DebuggerStatement;
    exports.DoWhileStatement = DoWhileStatement;
    exports.ForOfStatement = exports.ForInStatement = void 0;
    exports.ForStatement = ForStatement;
    exports.IfStatement = IfStatement;
    exports.LabeledStatement = LabeledStatement;
    exports.ReturnStatement = ReturnStatement;
    exports.SwitchCase = SwitchCase;
    exports.SwitchStatement = SwitchStatement;
    exports.ThrowStatement = ThrowStatement;
    exports.TryStatement = TryStatement;
    exports.VariableDeclaration = VariableDeclaration;
    exports.VariableDeclarator = VariableDeclarator;
    exports.WhileStatement = WhileStatement;
    exports.WithStatement = WithStatement;
    var _t = require_lib3();
    var {
      isFor,
      isForStatement,
      isIfStatement,
      isStatement
    } = _t;
    function WithStatement(node2) {
      this.word("with");
      this.space();
      this.tokenChar(40);
      this.print(node2.object, node2);
      this.tokenChar(41);
      this.printBlock(node2);
    }
    function IfStatement(node2) {
      this.word("if");
      this.space();
      this.tokenChar(40);
      this.print(node2.test, node2);
      this.tokenChar(41);
      this.space();
      const needsBlock = node2.alternate && isIfStatement(getLastStatement(node2.consequent));
      if (needsBlock) {
        this.tokenChar(123);
        this.newline();
        this.indent();
      }
      this.printAndIndentOnComments(node2.consequent, node2);
      if (needsBlock) {
        this.dedent();
        this.newline();
        this.tokenChar(125);
      }
      if (node2.alternate) {
        if (this.endsWith(125))
          this.space();
        this.word("else");
        this.space();
        this.printAndIndentOnComments(node2.alternate, node2);
      }
    }
    function getLastStatement(statement) {
      const {
        body
      } = statement;
      if (isStatement(body) === false) {
        return statement;
      }
      return getLastStatement(body);
    }
    function ForStatement(node2) {
      this.word("for");
      this.space();
      this.tokenChar(40);
      this.inForStatementInitCounter++;
      this.print(node2.init, node2);
      this.inForStatementInitCounter--;
      this.tokenChar(59);
      if (node2.test) {
        this.space();
        this.print(node2.test, node2);
      }
      this.tokenChar(59);
      if (node2.update) {
        this.space();
        this.print(node2.update, node2);
      }
      this.tokenChar(41);
      this.printBlock(node2);
    }
    function WhileStatement(node2) {
      this.word("while");
      this.space();
      this.tokenChar(40);
      this.print(node2.test, node2);
      this.tokenChar(41);
      this.printBlock(node2);
    }
    function ForXStatement(node2) {
      this.word("for");
      this.space();
      const isForOf = node2.type === "ForOfStatement";
      if (isForOf && node2.await) {
        this.word("await");
        this.space();
      }
      this.noIndentInnerCommentsHere();
      this.tokenChar(40);
      this.print(node2.left, node2);
      this.space();
      this.word(isForOf ? "of" : "in");
      this.space();
      this.print(node2.right, node2);
      this.tokenChar(41);
      this.printBlock(node2);
    }
    var ForInStatement2 = ForXStatement;
    exports.ForInStatement = ForInStatement2;
    var ForOfStatement = ForXStatement;
    exports.ForOfStatement = ForOfStatement;
    function DoWhileStatement(node2) {
      this.word("do");
      this.space();
      this.print(node2.body, node2);
      this.space();
      this.word("while");
      this.space();
      this.tokenChar(40);
      this.print(node2.test, node2);
      this.tokenChar(41);
      this.semicolon();
    }
    function printStatementAfterKeyword(printer, node2, parent, isLabel) {
      if (node2) {
        printer.space();
        printer.printTerminatorless(node2, parent, isLabel);
      }
      printer.semicolon();
    }
    function BreakStatement(node2) {
      this.word("break");
      printStatementAfterKeyword(this, node2.label, node2, true);
    }
    function ContinueStatement(node2) {
      this.word("continue");
      printStatementAfterKeyword(this, node2.label, node2, true);
    }
    function ReturnStatement(node2) {
      this.word("return");
      printStatementAfterKeyword(this, node2.argument, node2, false);
    }
    function ThrowStatement(node2) {
      this.word("throw");
      printStatementAfterKeyword(this, node2.argument, node2, false);
    }
    function LabeledStatement(node2) {
      this.print(node2.label, node2);
      this.tokenChar(58);
      this.space();
      this.print(node2.body, node2);
    }
    function TryStatement(node2) {
      this.word("try");
      this.space();
      this.print(node2.block, node2);
      this.space();
      if (node2.handlers) {
        this.print(node2.handlers[0], node2);
      } else {
        this.print(node2.handler, node2);
      }
      if (node2.finalizer) {
        this.space();
        this.word("finally");
        this.space();
        this.print(node2.finalizer, node2);
      }
    }
    function CatchClause(node2) {
      this.word("catch");
      this.space();
      if (node2.param) {
        this.tokenChar(40);
        this.print(node2.param, node2);
        this.print(node2.param.typeAnnotation, node2);
        this.tokenChar(41);
        this.space();
      }
      this.print(node2.body, node2);
    }
    function SwitchStatement(node2) {
      this.word("switch");
      this.space();
      this.tokenChar(40);
      this.print(node2.discriminant, node2);
      this.tokenChar(41);
      this.space();
      this.tokenChar(123);
      this.printSequence(node2.cases, node2, {
        indent: true,
        addNewlines(leading, cas) {
          if (!leading && node2.cases[node2.cases.length - 1] === cas)
            return -1;
        }
      });
      this.tokenChar(125);
    }
    function SwitchCase(node2) {
      if (node2.test) {
        this.word("case");
        this.space();
        this.print(node2.test, node2);
        this.tokenChar(58);
      } else {
        this.word("default");
        this.tokenChar(58);
      }
      if (node2.consequent.length) {
        this.newline();
        this.printSequence(node2.consequent, node2, {
          indent: true
        });
      }
    }
    function DebuggerStatement() {
      this.word("debugger");
      this.semicolon();
    }
    function VariableDeclaration(node2, parent) {
      if (node2.declare) {
        this.word("declare");
        this.space();
      }
      const {
        kind
      } = node2;
      this.word(kind, kind === "using");
      this.space();
      let hasInits = false;
      if (!isFor(parent)) {
        for (const declar of node2.declarations) {
          if (declar.init) {
            hasInits = true;
          }
        }
      }
      this.printList(node2.declarations, node2, {
        separator: hasInits ? function() {
          this.tokenChar(44);
          this.newline();
        } : void 0,
        indent: node2.declarations.length > 1 ? true : false
      });
      if (isFor(parent)) {
        if (isForStatement(parent)) {
          if (parent.init === node2)
            return;
        } else {
          if (parent.left === node2)
            return;
        }
      }
      this.semicolon();
    }
    function VariableDeclarator(node2) {
      this.print(node2.id, node2);
      if (node2.definite)
        this.tokenChar(33);
      this.print(node2.id.typeAnnotation, node2);
      if (node2.init) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.init, node2);
      }
    }
  }
});

// node_modules/@babel/generator/lib/generators/classes.js
var require_classes = __commonJS({
  "node_modules/@babel/generator/lib/generators/classes.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ClassAccessorProperty = ClassAccessorProperty;
    exports.ClassBody = ClassBody;
    exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
    exports.ClassMethod = ClassMethod;
    exports.ClassPrivateMethod = ClassPrivateMethod;
    exports.ClassPrivateProperty = ClassPrivateProperty;
    exports.ClassProperty = ClassProperty;
    exports.StaticBlock = StaticBlock;
    exports._classMethodHead = _classMethodHead;
    var _t = require_lib3();
    var {
      isExportDefaultDeclaration,
      isExportNamedDeclaration: isExportNamedDeclaration2
    } = _t;
    function ClassDeclaration(node2, parent) {
      const inExport = isExportDefaultDeclaration(parent) || isExportNamedDeclaration2(parent);
      if (!inExport || !this._shouldPrintDecoratorsBeforeExport(parent)) {
        this.printJoin(node2.decorators, node2);
      }
      if (node2.declare) {
        this.word("declare");
        this.space();
      }
      if (node2.abstract) {
        this.word("abstract");
        this.space();
      }
      this.word("class");
      if (node2.id) {
        this.space();
        this.print(node2.id, node2);
      }
      this.print(node2.typeParameters, node2);
      if (node2.superClass) {
        this.space();
        this.word("extends");
        this.space();
        this.print(node2.superClass, node2);
        this.print(node2.superTypeParameters, node2);
      }
      if (node2.implements) {
        this.space();
        this.word("implements");
        this.space();
        this.printList(node2.implements, node2);
      }
      this.space();
      this.print(node2.body, node2);
    }
    function ClassBody(node2) {
      this.tokenChar(123);
      if (node2.body.length === 0) {
        this.tokenChar(125);
      } else {
        this.newline();
        this.indent();
        this.printSequence(node2.body, node2);
        this.dedent();
        if (!this.endsWith(10))
          this.newline();
        this.sourceWithOffset("end", node2.loc, 0, -1);
        this.rightBrace();
      }
    }
    function ClassProperty(node2) {
      var _node$key$loc, _node$key$loc$end;
      this.printJoin(node2.decorators, node2);
      const endLine = (_node$key$loc = node2.key.loc) == null ? void 0 : (_node$key$loc$end = _node$key$loc.end) == null ? void 0 : _node$key$loc$end.line;
      if (endLine)
        this.catchUp(endLine);
      this.tsPrintClassMemberModifiers(node2);
      if (node2.computed) {
        this.tokenChar(91);
        this.print(node2.key, node2);
        this.tokenChar(93);
      } else {
        this._variance(node2);
        this.print(node2.key, node2);
      }
      if (node2.optional) {
        this.tokenChar(63);
      }
      if (node2.definite) {
        this.tokenChar(33);
      }
      this.print(node2.typeAnnotation, node2);
      if (node2.value) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.value, node2);
      }
      this.semicolon();
    }
    function ClassAccessorProperty(node2) {
      var _node$key$loc2, _node$key$loc2$end;
      this.printJoin(node2.decorators, node2);
      const endLine = (_node$key$loc2 = node2.key.loc) == null ? void 0 : (_node$key$loc2$end = _node$key$loc2.end) == null ? void 0 : _node$key$loc2$end.line;
      if (endLine)
        this.catchUp(endLine);
      this.tsPrintClassMemberModifiers(node2);
      this.word("accessor", true);
      this.space();
      if (node2.computed) {
        this.tokenChar(91);
        this.print(node2.key, node2);
        this.tokenChar(93);
      } else {
        this._variance(node2);
        this.print(node2.key, node2);
      }
      if (node2.optional) {
        this.tokenChar(63);
      }
      if (node2.definite) {
        this.tokenChar(33);
      }
      this.print(node2.typeAnnotation, node2);
      if (node2.value) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.value, node2);
      }
      this.semicolon();
    }
    function ClassPrivateProperty(node2) {
      this.printJoin(node2.decorators, node2);
      if (node2.static) {
        this.word("static");
        this.space();
      }
      this.print(node2.key, node2);
      this.print(node2.typeAnnotation, node2);
      if (node2.value) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.value, node2);
      }
      this.semicolon();
    }
    function ClassMethod(node2) {
      this._classMethodHead(node2);
      this.space();
      this.print(node2.body, node2);
    }
    function ClassPrivateMethod(node2) {
      this._classMethodHead(node2);
      this.space();
      this.print(node2.body, node2);
    }
    function _classMethodHead(node2) {
      var _node$key$loc3, _node$key$loc3$end;
      this.printJoin(node2.decorators, node2);
      const endLine = (_node$key$loc3 = node2.key.loc) == null ? void 0 : (_node$key$loc3$end = _node$key$loc3.end) == null ? void 0 : _node$key$loc3$end.line;
      if (endLine)
        this.catchUp(endLine);
      this.tsPrintClassMemberModifiers(node2);
      this._methodHead(node2);
    }
    function StaticBlock(node2) {
      this.word("static");
      this.space();
      this.tokenChar(123);
      if (node2.body.length === 0) {
        this.tokenChar(125);
      } else {
        this.newline();
        this.printSequence(node2.body, node2, {
          indent: true
        });
        this.sourceWithOffset("end", node2.loc, 0, -1);
        this.rightBrace();
      }
    }
  }
});

// node_modules/@babel/generator/lib/generators/methods.js
var require_methods = __commonJS({
  "node_modules/@babel/generator/lib/generators/methods.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ArrowFunctionExpression = ArrowFunctionExpression;
    exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
    exports._functionHead = _functionHead;
    exports._methodHead = _methodHead;
    exports._param = _param;
    exports._parameters = _parameters;
    exports._params = _params;
    exports._predicate = _predicate;
    var _t = require_lib3();
    var {
      isIdentifier: isIdentifier3
    } = _t;
    function _params(node2, idNode, parentNode) {
      this.print(node2.typeParameters, node2);
      const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
      if (nameInfo) {
        this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
      }
      this.tokenChar(40);
      this._parameters(node2.params, node2);
      this.tokenChar(41);
      const noLineTerminator = node2.type === "ArrowFunctionExpression";
      this.print(node2.returnType, node2, noLineTerminator);
      this._noLineTerminator = noLineTerminator;
    }
    function _parameters(parameters, parent) {
      const paramLength = parameters.length;
      for (let i = 0; i < paramLength; i++) {
        this._param(parameters[i], parent);
        if (i < parameters.length - 1) {
          this.tokenChar(44);
          this.space();
        }
      }
    }
    function _param(parameter, parent) {
      this.printJoin(parameter.decorators, parameter);
      this.print(parameter, parent);
      if (parameter.optional) {
        this.tokenChar(63);
      }
      this.print(parameter.typeAnnotation, parameter);
    }
    function _methodHead(node2) {
      const kind = node2.kind;
      const key2 = node2.key;
      if (kind === "get" || kind === "set") {
        this.word(kind);
        this.space();
      }
      if (node2.async) {
        this.word("async", true);
        this.space();
      }
      if (kind === "method" || kind === "init") {
        if (node2.generator) {
          this.tokenChar(42);
        }
      }
      if (node2.computed) {
        this.tokenChar(91);
        this.print(key2, node2);
        this.tokenChar(93);
      } else {
        this.print(key2, node2);
      }
      if (node2.optional) {
        this.tokenChar(63);
      }
      this._params(node2, node2.computed && node2.key.type !== "StringLiteral" ? void 0 : node2.key, void 0);
    }
    function _predicate(node2, noLineTerminatorAfter) {
      if (node2.predicate) {
        if (!node2.returnType) {
          this.tokenChar(58);
        }
        this.space();
        this.print(node2.predicate, node2, noLineTerminatorAfter);
      }
    }
    function _functionHead(node2, parent) {
      if (node2.async) {
        this.word("async");
        this._endsWithInnerRaw = false;
        this.space();
      }
      this.word("function");
      if (node2.generator) {
        this._endsWithInnerRaw = false;
        this.tokenChar(42);
      }
      this.space();
      if (node2.id) {
        this.print(node2.id, node2);
      }
      this._params(node2, node2.id, parent);
      if (node2.type !== "TSDeclareFunction") {
        this._predicate(node2);
      }
    }
    function FunctionExpression(node2, parent) {
      this._functionHead(node2, parent);
      this.space();
      this.print(node2.body, node2);
    }
    function ArrowFunctionExpression(node2, parent) {
      if (node2.async) {
        this.word("async", true);
        this.space();
      }
      let firstParam;
      if (!this.format.retainLines && node2.params.length === 1 && isIdentifier3(firstParam = node2.params[0]) && !hasTypesOrComments(node2, firstParam)) {
        this.print(firstParam, node2, true);
      } else {
        this._params(node2, void 0, parent);
      }
      this._predicate(node2, true);
      this.space();
      this.printInnerComments();
      this.token("=>");
      this.space();
      this.print(node2.body, node2);
    }
    function hasTypesOrComments(node2, param) {
      var _param$leadingComment, _param$trailingCommen;
      return !!(node2.typeParameters || node2.returnType || node2.predicate || param.typeAnnotation || param.optional || (_param$leadingComment = param.leadingComments) != null && _param$leadingComment.length || (_param$trailingCommen = param.trailingComments) != null && _param$trailingCommen.length);
    }
    function _getFuncIdName(idNode, parent) {
      let id = idNode;
      if (!id && parent) {
        const parentType = parent.type;
        if (parentType === "VariableDeclarator") {
          id = parent.id;
        } else if (parentType === "AssignmentExpression" || parentType === "AssignmentPattern") {
          id = parent.left;
        } else if (parentType === "ObjectProperty" || parentType === "ClassProperty") {
          if (!parent.computed || parent.key.type === "StringLiteral") {
            id = parent.key;
          }
        } else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") {
          id = parent.key;
        }
      }
      if (!id)
        return;
      let nameInfo;
      if (id.type === "Identifier") {
        var _id$loc, _id$loc2;
        nameInfo = {
          pos: (_id$loc = id.loc) == null ? void 0 : _id$loc.start,
          name: ((_id$loc2 = id.loc) == null ? void 0 : _id$loc2.identifierName) || id.name
        };
      } else if (id.type === "PrivateName") {
        var _id$loc3;
        nameInfo = {
          pos: (_id$loc3 = id.loc) == null ? void 0 : _id$loc3.start,
          name: "#" + id.id.name
        };
      } else if (id.type === "StringLiteral") {
        var _id$loc4;
        nameInfo = {
          pos: (_id$loc4 = id.loc) == null ? void 0 : _id$loc4.start,
          name: id.value
        };
      }
      return nameInfo;
    }
  }
});

// node_modules/@babel/generator/lib/generators/modules.js
var require_modules = __commonJS({
  "node_modules/@babel/generator/lib/generators/modules.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ExportAllDeclaration = ExportAllDeclaration;
    exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
    exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
    exports.ExportNamedDeclaration = ExportNamedDeclaration;
    exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
    exports.ExportSpecifier = ExportSpecifier;
    exports.ImportAttribute = ImportAttribute;
    exports.ImportDeclaration = ImportDeclaration;
    exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
    exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
    exports.ImportSpecifier = ImportSpecifier;
    exports._printAssertions = _printAssertions;
    var _t = require_lib3();
    var {
      isClassDeclaration,
      isExportDefaultSpecifier,
      isExportNamespaceSpecifier,
      isImportDefaultSpecifier,
      isImportNamespaceSpecifier,
      isStatement
    } = _t;
    function ImportSpecifier(node2) {
      if (node2.importKind === "type" || node2.importKind === "typeof") {
        this.word(node2.importKind);
        this.space();
      }
      this.print(node2.imported, node2);
      if (node2.local && node2.local.name !== node2.imported.name) {
        this.space();
        this.word("as");
        this.space();
        this.print(node2.local, node2);
      }
    }
    function ImportDefaultSpecifier(node2) {
      this.print(node2.local, node2);
    }
    function ExportDefaultSpecifier(node2) {
      this.print(node2.exported, node2);
    }
    function ExportSpecifier(node2) {
      if (node2.exportKind === "type") {
        this.word("type");
        this.space();
      }
      this.print(node2.local, node2);
      if (node2.exported && node2.local.name !== node2.exported.name) {
        this.space();
        this.word("as");
        this.space();
        this.print(node2.exported, node2);
      }
    }
    function ExportNamespaceSpecifier(node2) {
      this.tokenChar(42);
      this.space();
      this.word("as");
      this.space();
      this.print(node2.exported, node2);
    }
    function _printAssertions(node2) {
      this.word("assert");
      this.space();
      this.tokenChar(123);
      this.space();
      this.printList(node2.assertions, node2);
      this.space();
      this.tokenChar(125);
    }
    function ExportAllDeclaration(node2) {
      var _node$assertions;
      this.word("export");
      this.space();
      if (node2.exportKind === "type") {
        this.word("type");
        this.space();
      }
      this.tokenChar(42);
      this.space();
      this.word("from");
      this.space();
      if ((_node$assertions = node2.assertions) != null && _node$assertions.length) {
        this.print(node2.source, node2, true);
        this.space();
        this._printAssertions(node2);
      } else {
        this.print(node2.source, node2);
      }
      this.semicolon();
    }
    function maybePrintDecoratorsBeforeExport(printer, node2) {
      if (isClassDeclaration(node2.declaration) && printer._shouldPrintDecoratorsBeforeExport(node2)) {
        printer.printJoin(node2.declaration.decorators, node2);
      }
    }
    function ExportNamedDeclaration(node2) {
      maybePrintDecoratorsBeforeExport(this, node2);
      this.word("export");
      this.space();
      if (node2.declaration) {
        const declar = node2.declaration;
        this.print(declar, node2);
        if (!isStatement(declar))
          this.semicolon();
      } else {
        if (node2.exportKind === "type") {
          this.word("type");
          this.space();
        }
        const specifiers = node2.specifiers.slice(0);
        let hasSpecial = false;
        for (; ; ) {
          const first = specifiers[0];
          if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) {
            hasSpecial = true;
            this.print(specifiers.shift(), node2);
            if (specifiers.length) {
              this.tokenChar(44);
              this.space();
            }
          } else {
            break;
          }
        }
        if (specifiers.length || !specifiers.length && !hasSpecial) {
          this.tokenChar(123);
          if (specifiers.length) {
            this.space();
            this.printList(specifiers, node2);
            this.space();
          }
          this.tokenChar(125);
        }
        if (node2.source) {
          var _node$assertions2;
          this.space();
          this.word("from");
          this.space();
          if ((_node$assertions2 = node2.assertions) != null && _node$assertions2.length) {
            this.print(node2.source, node2, true);
            this.space();
            this._printAssertions(node2);
          } else {
            this.print(node2.source, node2);
          }
        }
        this.semicolon();
      }
    }
    function ExportDefaultDeclaration(node2) {
      maybePrintDecoratorsBeforeExport(this, node2);
      this.word("export");
      this.noIndentInnerCommentsHere();
      this.space();
      this.word("default");
      this.space();
      const declar = node2.declaration;
      this.print(declar, node2);
      if (!isStatement(declar))
        this.semicolon();
    }
    function ImportDeclaration(node2) {
      var _node$assertions3;
      this.word("import");
      this.space();
      const isTypeKind = node2.importKind === "type" || node2.importKind === "typeof";
      if (isTypeKind) {
        this.noIndentInnerCommentsHere();
        this.word(node2.importKind);
        this.space();
      } else if (node2.module) {
        this.noIndentInnerCommentsHere();
        this.word("module");
        this.space();
      }
      const specifiers = node2.specifiers.slice(0);
      const hasSpecifiers = !!specifiers.length;
      while (hasSpecifiers) {
        const first = specifiers[0];
        if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
          this.print(specifiers.shift(), node2);
          if (specifiers.length) {
            this.tokenChar(44);
            this.space();
          }
        } else {
          break;
        }
      }
      if (specifiers.length) {
        this.tokenChar(123);
        this.space();
        this.printList(specifiers, node2);
        this.space();
        this.tokenChar(125);
      } else if (isTypeKind && !hasSpecifiers) {
        this.tokenChar(123);
        this.tokenChar(125);
      }
      if (hasSpecifiers || isTypeKind) {
        this.space();
        this.word("from");
        this.space();
      }
      if ((_node$assertions3 = node2.assertions) != null && _node$assertions3.length) {
        this.print(node2.source, node2, true);
        this.space();
        this._printAssertions(node2);
      } else {
        this.print(node2.source, node2);
      }
      {
        var _node$attributes;
        if ((_node$attributes = node2.attributes) != null && _node$attributes.length) {
          this.space();
          this.word("with");
          this.space();
          this.printList(node2.attributes, node2);
        }
      }
      this.semicolon();
    }
    function ImportAttribute(node2) {
      this.print(node2.key);
      this.tokenChar(58);
      this.space();
      this.print(node2.value);
    }
    function ImportNamespaceSpecifier(node2) {
      this.tokenChar(42);
      this.space();
      this.word("as");
      this.space();
      this.print(node2.local, node2);
    }
  }
});

// node_modules/jsesc/jsesc.js
var require_jsesc = __commonJS({
  "node_modules/jsesc/jsesc.js"(exports, module2) {
    "use strict";
    var object = {};
    var hasOwnProperty4 = object.hasOwnProperty;
    var forOwn = (object2, callback) => {
      for (const key2 in object2) {
        if (hasOwnProperty4.call(object2, key2)) {
          callback(key2, object2[key2]);
        }
      }
    };
    var extend4 = (destination, source2) => {
      if (!source2) {
        return destination;
      }
      forOwn(source2, (key2, value2) => {
        destination[key2] = value2;
      });
      return destination;
    };
    var forEach = (array, callback) => {
      const length = array.length;
      let index2 = -1;
      while (++index2 < length) {
        callback(array[index2]);
      }
    };
    var toString4 = object.toString;
    var isArray3 = Array.isArray;
    var isBuffer2 = Buffer.isBuffer;
    var isObject = (value2) => {
      return toString4.call(value2) == "[object Object]";
    };
    var isString = (value2) => {
      return typeof value2 == "string" || toString4.call(value2) == "[object String]";
    };
    var isNumber = (value2) => {
      return typeof value2 == "number" || toString4.call(value2) == "[object Number]";
    };
    var isFunction = (value2) => {
      return typeof value2 == "function";
    };
    var isMap = (value2) => {
      return toString4.call(value2) == "[object Map]";
    };
    var isSet = (value2) => {
      return toString4.call(value2) == "[object Set]";
    };
    var singleEscapes = {
      '"': '\\"',
      "'": "\\'",
      "\\": "\\\\",
      "\b": "\\b",
      "\f": "\\f",
      "\n": "\\n",
      "\r": "\\r",
      "	": "\\t"
      // `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'.
      // '\v': '\\x0B'
    };
    var regexSingleEscape = /["'\\\b\f\n\r\t]/;
    var regexDigit = /[0-9]/;
    var regexWhitelist = /[ !#-&\(-\[\]-_a-~]/;
    var jsesc = (argument, options) => {
      const increaseIndentation = () => {
        oldIndent = indent;
        ++options.indentLevel;
        indent = options.indent.repeat(options.indentLevel);
      };
      const defaults = {
        "escapeEverything": false,
        "minimal": false,
        "isScriptContext": false,
        "quotes": "single",
        "wrap": false,
        "es6": false,
        "json": false,
        "compact": true,
        "lowercaseHex": false,
        "numbers": "decimal",
        "indent": "	",
        "indentLevel": 0,
        "__inline1__": false,
        "__inline2__": false
      };
      const json = options && options.json;
      if (json) {
        defaults.quotes = "double";
        defaults.wrap = true;
      }
      options = extend4(defaults, options);
      if (options.quotes != "single" && options.quotes != "double" && options.quotes != "backtick") {
        options.quotes = "single";
      }
      const quote = options.quotes == "double" ? '"' : options.quotes == "backtick" ? "`" : "'";
      const compact = options.compact;
      const lowercaseHex = options.lowercaseHex;
      let indent = options.indent.repeat(options.indentLevel);
      let oldIndent = "";
      const inline1 = options.__inline1__;
      const inline2 = options.__inline2__;
      const newLine = compact ? "" : "\n";
      let result;
      let isEmpty = true;
      const useBinNumbers = options.numbers == "binary";
      const useOctNumbers = options.numbers == "octal";
      const useDecNumbers = options.numbers == "decimal";
      const useHexNumbers = options.numbers == "hexadecimal";
      if (json && argument && isFunction(argument.toJSON)) {
        argument = argument.toJSON();
      }
      if (!isString(argument)) {
        if (isMap(argument)) {
          if (argument.size == 0) {
            return "new Map()";
          }
          if (!compact) {
            options.__inline1__ = true;
            options.__inline2__ = false;
          }
          return "new Map(" + jsesc(Array.from(argument), options) + ")";
        }
        if (isSet(argument)) {
          if (argument.size == 0) {
            return "new Set()";
          }
          return "new Set(" + jsesc(Array.from(argument), options) + ")";
        }
        if (isBuffer2(argument)) {
          if (argument.length == 0) {
            return "Buffer.from([])";
          }
          return "Buffer.from(" + jsesc(Array.from(argument), options) + ")";
        }
        if (isArray3(argument)) {
          result = [];
          options.wrap = true;
          if (inline1) {
            options.__inline1__ = false;
            options.__inline2__ = true;
          }
          if (!inline2) {
            increaseIndentation();
          }
          forEach(argument, (value2) => {
            isEmpty = false;
            if (inline2) {
              options.__inline2__ = false;
            }
            result.push(
              (compact || inline2 ? "" : indent) + jsesc(value2, options)
            );
          });
          if (isEmpty) {
            return "[]";
          }
          if (inline2) {
            return "[" + result.join(", ") + "]";
          }
          return "[" + newLine + result.join("," + newLine) + newLine + (compact ? "" : oldIndent) + "]";
        } else if (isNumber(argument)) {
          if (json) {
            return JSON.stringify(argument);
          }
          if (useDecNumbers) {
            return String(argument);
          }
          if (useHexNumbers) {
            let hexadecimal = argument.toString(16);
            if (!lowercaseHex) {
              hexadecimal = hexadecimal.toUpperCase();
            }
            return "0x" + hexadecimal;
          }
          if (useBinNumbers) {
            return "0b" + argument.toString(2);
          }
          if (useOctNumbers) {
            return "0o" + argument.toString(8);
          }
        } else if (!isObject(argument)) {
          if (json) {
            return JSON.stringify(argument) || "null";
          }
          return String(argument);
        } else {
          result = [];
          options.wrap = true;
          increaseIndentation();
          forOwn(argument, (key2, value2) => {
            isEmpty = false;
            result.push(
              (compact ? "" : indent) + jsesc(key2, options) + ":" + (compact ? "" : " ") + jsesc(value2, options)
            );
          });
          if (isEmpty) {
            return "{}";
          }
          return "{" + newLine + result.join("," + newLine) + newLine + (compact ? "" : oldIndent) + "}";
        }
      }
      const string3 = argument;
      let index2 = -1;
      const length = string3.length;
      result = "";
      while (++index2 < length) {
        const character = string3.charAt(index2);
        if (options.es6) {
          const first = string3.charCodeAt(index2);
          if (
            // check if it’s the start of a surrogate pair
            first >= 55296 && first <= 56319 && // high surrogate
            length > index2 + 1
          ) {
            const second = string3.charCodeAt(index2 + 1);
            if (second >= 56320 && second <= 57343) {
              const codePoint = (first - 55296) * 1024 + second - 56320 + 65536;
              let hexadecimal2 = codePoint.toString(16);
              if (!lowercaseHex) {
                hexadecimal2 = hexadecimal2.toUpperCase();
              }
              result += "\\u{" + hexadecimal2 + "}";
              ++index2;
              continue;
            }
          }
        }
        if (!options.escapeEverything) {
          if (regexWhitelist.test(character)) {
            result += character;
            continue;
          }
          if (character == '"') {
            result += quote == character ? '\\"' : character;
            continue;
          }
          if (character == "`") {
            result += quote == character ? "\\`" : character;
            continue;
          }
          if (character == "'") {
            result += quote == character ? "\\'" : character;
            continue;
          }
        }
        if (character == "\0" && !json && !regexDigit.test(string3.charAt(index2 + 1))) {
          result += "\\0";
          continue;
        }
        if (regexSingleEscape.test(character)) {
          result += singleEscapes[character];
          continue;
        }
        const charCode = character.charCodeAt(0);
        if (options.minimal && charCode != 8232 && charCode != 8233) {
          result += character;
          continue;
        }
        let hexadecimal = charCode.toString(16);
        if (!lowercaseHex) {
          hexadecimal = hexadecimal.toUpperCase();
        }
        const longhand = hexadecimal.length > 2 || json;
        const escaped = "\\" + (longhand ? "u" : "x") + ("0000" + hexadecimal).slice(longhand ? -4 : -2);
        result += escaped;
        continue;
      }
      if (options.wrap) {
        result = quote + result + quote;
      }
      if (quote == "`") {
        result = result.replace(/\$\{/g, "\\${");
      }
      if (options.isScriptContext) {
        return result.replace(/<\/(script|style)/gi, "<\\/$1").replace(/<!--/g, json ? "\\u003C!--" : "\\x3C!--");
      }
      return result;
    };
    jsesc.version = "2.5.2";
    module2.exports = jsesc;
  }
});

// node_modules/@babel/generator/lib/generators/types.js
var require_types = __commonJS({
  "node_modules/@babel/generator/lib/generators/types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ArgumentPlaceholder = ArgumentPlaceholder;
    exports.ArrayPattern = exports.ArrayExpression = ArrayExpression2;
    exports.BigIntLiteral = BigIntLiteral;
    exports.BooleanLiteral = BooleanLiteral;
    exports.DecimalLiteral = DecimalLiteral;
    exports.Identifier = Identifier;
    exports.NullLiteral = NullLiteral;
    exports.NumericLiteral = NumericLiteral;
    exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
    exports.ObjectMethod = ObjectMethod;
    exports.ObjectProperty = ObjectProperty;
    exports.PipelineBareFunction = PipelineBareFunction;
    exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
    exports.PipelineTopicExpression = PipelineTopicExpression;
    exports.RecordExpression = RecordExpression;
    exports.RegExpLiteral = RegExpLiteral;
    exports.SpreadElement = exports.RestElement = RestElement2;
    exports.StringLiteral = StringLiteral;
    exports.TopicReference = TopicReference;
    exports.TupleExpression = TupleExpression;
    var _t = require_lib3();
    var _jsesc = require_jsesc();
    var {
      isAssignmentPattern,
      isIdentifier: isIdentifier3
    } = _t;
    function Identifier(node2) {
      var _node$loc;
      this.sourceIdentifierName(((_node$loc = node2.loc) == null ? void 0 : _node$loc.identifierName) || node2.name);
      this.word(node2.name);
    }
    function ArgumentPlaceholder() {
      this.tokenChar(63);
    }
    function RestElement2(node2) {
      this.token("...");
      this.print(node2.argument, node2);
    }
    function ObjectExpression(node2) {
      const props = node2.properties;
      this.tokenChar(123);
      if (props.length) {
        this.space();
        this.printList(props, node2, {
          indent: true,
          statement: true
        });
        this.space();
      }
      this.sourceWithOffset("end", node2.loc, 0, -1);
      this.tokenChar(125);
    }
    function ObjectMethod(node2) {
      this.printJoin(node2.decorators, node2);
      this._methodHead(node2);
      this.space();
      this.print(node2.body, node2);
    }
    function ObjectProperty(node2) {
      this.printJoin(node2.decorators, node2);
      if (node2.computed) {
        this.tokenChar(91);
        this.print(node2.key, node2);
        this.tokenChar(93);
      } else {
        if (isAssignmentPattern(node2.value) && isIdentifier3(node2.key) && node2.key.name === node2.value.left.name) {
          this.print(node2.value, node2);
          return;
        }
        this.print(node2.key, node2);
        if (node2.shorthand && isIdentifier3(node2.key) && isIdentifier3(node2.value) && node2.key.name === node2.value.name) {
          return;
        }
      }
      this.tokenChar(58);
      this.space();
      this.print(node2.value, node2);
    }
    function ArrayExpression2(node2) {
      const elems = node2.elements;
      const len = elems.length;
      this.tokenChar(91);
      for (let i = 0; i < elems.length; i++) {
        const elem = elems[i];
        if (elem) {
          if (i > 0)
            this.space();
          this.print(elem, node2);
          if (i < len - 1)
            this.tokenChar(44);
        } else {
          this.tokenChar(44);
        }
      }
      this.tokenChar(93);
    }
    function RecordExpression(node2) {
      const props = node2.properties;
      let startToken;
      let endToken;
      if (this.format.recordAndTupleSyntaxType === "bar") {
        startToken = "{|";
        endToken = "|}";
      } else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) {
        throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
      } else {
        startToken = "#{";
        endToken = "}";
      }
      this.token(startToken);
      if (props.length) {
        this.space();
        this.printList(props, node2, {
          indent: true,
          statement: true
        });
        this.space();
      }
      this.token(endToken);
    }
    function TupleExpression(node2) {
      const elems = node2.elements;
      const len = elems.length;
      let startToken;
      let endToken;
      if (this.format.recordAndTupleSyntaxType === "bar") {
        startToken = "[|";
        endToken = "|]";
      } else if (this.format.recordAndTupleSyntaxType === "hash") {
        startToken = "#[";
        endToken = "]";
      } else {
        throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
      }
      this.token(startToken);
      for (let i = 0; i < elems.length; i++) {
        const elem = elems[i];
        if (elem) {
          if (i > 0)
            this.space();
          this.print(elem, node2);
          if (i < len - 1)
            this.tokenChar(44);
        }
      }
      this.token(endToken);
    }
    function RegExpLiteral(node2) {
      this.word(`/${node2.pattern}/${node2.flags}`);
    }
    function BooleanLiteral(node2) {
      this.word(node2.value ? "true" : "false");
    }
    function NullLiteral() {
      this.word("null");
    }
    function NumericLiteral(node2) {
      const raw = this.getPossibleRaw(node2);
      const opts = this.format.jsescOption;
      const value2 = node2.value + "";
      if (opts.numbers) {
        this.number(_jsesc(node2.value, opts));
      } else if (raw == null) {
        this.number(value2);
      } else if (this.format.minified) {
        this.number(raw.length < value2.length ? raw : value2);
      } else {
        this.number(raw);
      }
    }
    function StringLiteral(node2) {
      const raw = this.getPossibleRaw(node2);
      if (!this.format.minified && raw !== void 0) {
        this.token(raw);
        return;
      }
      const val = _jsesc(node2.value, this.format.jsescOption);
      this.token(val);
    }
    function BigIntLiteral(node2) {
      const raw = this.getPossibleRaw(node2);
      if (!this.format.minified && raw !== void 0) {
        this.word(raw);
        return;
      }
      this.word(node2.value + "n");
    }
    function DecimalLiteral(node2) {
      const raw = this.getPossibleRaw(node2);
      if (!this.format.minified && raw !== void 0) {
        this.word(raw);
        return;
      }
      this.word(node2.value + "m");
    }
    var validTopicTokenSet = /* @__PURE__ */ new Set(["^^", "@@", "^", "%", "#"]);
    function TopicReference() {
      const {
        topicToken
      } = this.format;
      if (validTopicTokenSet.has(topicToken)) {
        this.token(topicToken);
      } else {
        const givenTopicTokenJSON = JSON.stringify(topicToken);
        const validTopics = Array.from(validTopicTokenSet, (v) => JSON.stringify(v));
        throw new Error(`The "topicToken" generator option must be one of ${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
      }
    }
    function PipelineTopicExpression(node2) {
      this.print(node2.expression, node2);
    }
    function PipelineBareFunction(node2) {
      this.print(node2.callee, node2);
    }
    function PipelinePrimaryTopicReference() {
      this.tokenChar(35);
    }
  }
});

// node_modules/@babel/generator/lib/generators/flow.js
var require_flow2 = __commonJS({
  "node_modules/@babel/generator/lib/generators/flow.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.AnyTypeAnnotation = AnyTypeAnnotation;
    exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
    exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
    exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
    exports.DeclareClass = DeclareClass;
    exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
    exports.DeclareExportDeclaration = DeclareExportDeclaration;
    exports.DeclareFunction = DeclareFunction;
    exports.DeclareInterface = DeclareInterface;
    exports.DeclareModule = DeclareModule;
    exports.DeclareModuleExports = DeclareModuleExports;
    exports.DeclareOpaqueType = DeclareOpaqueType;
    exports.DeclareTypeAlias = DeclareTypeAlias;
    exports.DeclareVariable = DeclareVariable;
    exports.DeclaredPredicate = DeclaredPredicate;
    exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
    exports.EnumBooleanBody = EnumBooleanBody;
    exports.EnumBooleanMember = EnumBooleanMember;
    exports.EnumDeclaration = EnumDeclaration;
    exports.EnumDefaultedMember = EnumDefaultedMember;
    exports.EnumNumberBody = EnumNumberBody;
    exports.EnumNumberMember = EnumNumberMember;
    exports.EnumStringBody = EnumStringBody;
    exports.EnumStringMember = EnumStringMember;
    exports.EnumSymbolBody = EnumSymbolBody;
    exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
    exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
    exports.FunctionTypeParam = FunctionTypeParam;
    exports.IndexedAccessType = IndexedAccessType;
    exports.InferredPredicate = InferredPredicate;
    exports.InterfaceDeclaration = InterfaceDeclaration;
    exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
    exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
    exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
    exports.MixedTypeAnnotation = MixedTypeAnnotation;
    exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
    exports.NullableTypeAnnotation = NullableTypeAnnotation;
    Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _types2.NumericLiteral;
      }
    });
    exports.NumberTypeAnnotation = NumberTypeAnnotation;
    exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
    exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
    exports.ObjectTypeIndexer = ObjectTypeIndexer;
    exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
    exports.ObjectTypeProperty = ObjectTypeProperty;
    exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
    exports.OpaqueType = OpaqueType;
    exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
    exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
    Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
      enumerable: true,
      get: function() {
        return _types2.StringLiteral;
      }
    });
    exports.StringTypeAnnotation = StringTypeAnnotation;
    exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
    exports.ThisTypeAnnotation = ThisTypeAnnotation;
    exports.TupleTypeAnnotation = TupleTypeAnnotation;
    exports.TypeAlias = TypeAlias;
    exports.TypeAnnotation = TypeAnnotation;
    exports.TypeCastExpression = TypeCastExpression;
    exports.TypeParameter = TypeParameter;
    exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
    exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
    exports.UnionTypeAnnotation = UnionTypeAnnotation;
    exports.Variance = Variance;
    exports.VoidTypeAnnotation = VoidTypeAnnotation;
    exports._interfaceish = _interfaceish;
    exports._variance = _variance;
    var _t = require_lib3();
    var _modules = require_modules();
    var _types2 = require_types();
    var {
      isDeclareExportDeclaration,
      isStatement
    } = _t;
    function AnyTypeAnnotation() {
      this.word("any");
    }
    function ArrayTypeAnnotation(node2) {
      this.print(node2.elementType, node2, true);
      this.tokenChar(91);
      this.tokenChar(93);
    }
    function BooleanTypeAnnotation() {
      this.word("boolean");
    }
    function BooleanLiteralTypeAnnotation(node2) {
      this.word(node2.value ? "true" : "false");
    }
    function NullLiteralTypeAnnotation() {
      this.word("null");
    }
    function DeclareClass(node2, parent) {
      if (!isDeclareExportDeclaration(parent)) {
        this.word("declare");
        this.space();
      }
      this.word("class");
      this.space();
      this._interfaceish(node2);
    }
    function DeclareFunction(node2, parent) {
      if (!isDeclareExportDeclaration(parent)) {
        this.word("declare");
        this.space();
      }
      this.word("function");
      this.space();
      this.print(node2.id, node2);
      this.print(node2.id.typeAnnotation.typeAnnotation, node2);
      if (node2.predicate) {
        this.space();
        this.print(node2.predicate, node2);
      }
      this.semicolon();
    }
    function InferredPredicate() {
      this.tokenChar(37);
      this.word("checks");
    }
    function DeclaredPredicate(node2) {
      this.tokenChar(37);
      this.word("checks");
      this.tokenChar(40);
      this.print(node2.value, node2);
      this.tokenChar(41);
    }
    function DeclareInterface(node2) {
      this.word("declare");
      this.space();
      this.InterfaceDeclaration(node2);
    }
    function DeclareModule(node2) {
      this.word("declare");
      this.space();
      this.word("module");
      this.space();
      this.print(node2.id, node2);
      this.space();
      this.print(node2.body, node2);
    }
    function DeclareModuleExports(node2) {
      this.word("declare");
      this.space();
      this.word("module");
      this.tokenChar(46);
      this.word("exports");
      this.print(node2.typeAnnotation, node2);
    }
    function DeclareTypeAlias(node2) {
      this.word("declare");
      this.space();
      this.TypeAlias(node2);
    }
    function DeclareOpaqueType(node2, parent) {
      if (!isDeclareExportDeclaration(parent)) {
        this.word("declare");
        this.space();
      }
      this.OpaqueType(node2);
    }
    function DeclareVariable(node2, parent) {
      if (!isDeclareExportDeclaration(parent)) {
        this.word("declare");
        this.space();
      }
      this.word("var");
      this.space();
      this.print(node2.id, node2);
      this.print(node2.id.typeAnnotation, node2);
      this.semicolon();
    }
    function DeclareExportDeclaration(node2) {
      this.word("declare");
      this.space();
      this.word("export");
      this.space();
      if (node2.default) {
        this.word("default");
        this.space();
      }
      FlowExportDeclaration.call(this, node2);
    }
    function DeclareExportAllDeclaration(node2) {
      this.word("declare");
      this.space();
      _modules.ExportAllDeclaration.call(this, node2);
    }
    function EnumDeclaration(node2) {
      const {
        id,
        body
      } = node2;
      this.word("enum");
      this.space();
      this.print(id, node2);
      this.print(body, node2);
    }
    function enumExplicitType(context, name2, hasExplicitType) {
      if (hasExplicitType) {
        context.space();
        context.word("of");
        context.space();
        context.word(name2);
      }
      context.space();
    }
    function enumBody(context, node2) {
      const {
        members
      } = node2;
      context.token("{");
      context.indent();
      context.newline();
      for (const member of members) {
        context.print(member, node2);
        context.newline();
      }
      if (node2.hasUnknownMembers) {
        context.token("...");
        context.newline();
      }
      context.dedent();
      context.token("}");
    }
    function EnumBooleanBody(node2) {
      const {
        explicitType
      } = node2;
      enumExplicitType(this, "boolean", explicitType);
      enumBody(this, node2);
    }
    function EnumNumberBody(node2) {
      const {
        explicitType
      } = node2;
      enumExplicitType(this, "number", explicitType);
      enumBody(this, node2);
    }
    function EnumStringBody(node2) {
      const {
        explicitType
      } = node2;
      enumExplicitType(this, "string", explicitType);
      enumBody(this, node2);
    }
    function EnumSymbolBody(node2) {
      enumExplicitType(this, "symbol", true);
      enumBody(this, node2);
    }
    function EnumDefaultedMember(node2) {
      const {
        id
      } = node2;
      this.print(id, node2);
      this.tokenChar(44);
    }
    function enumInitializedMember(context, node2) {
      const {
        id,
        init
      } = node2;
      context.print(id, node2);
      context.space();
      context.token("=");
      context.space();
      context.print(init, node2);
      context.token(",");
    }
    function EnumBooleanMember(node2) {
      enumInitializedMember(this, node2);
    }
    function EnumNumberMember(node2) {
      enumInitializedMember(this, node2);
    }
    function EnumStringMember(node2) {
      enumInitializedMember(this, node2);
    }
    function FlowExportDeclaration(node2) {
      if (node2.declaration) {
        const declar = node2.declaration;
        this.print(declar, node2);
        if (!isStatement(declar))
          this.semicolon();
      } else {
        this.tokenChar(123);
        if (node2.specifiers.length) {
          this.space();
          this.printList(node2.specifiers, node2);
          this.space();
        }
        this.tokenChar(125);
        if (node2.source) {
          this.space();
          this.word("from");
          this.space();
          this.print(node2.source, node2);
        }
        this.semicolon();
      }
    }
    function ExistsTypeAnnotation() {
      this.tokenChar(42);
    }
    function FunctionTypeAnnotation(node2, parent) {
      this.print(node2.typeParameters, node2);
      this.tokenChar(40);
      if (node2.this) {
        this.word("this");
        this.tokenChar(58);
        this.space();
        this.print(node2.this.typeAnnotation, node2);
        if (node2.params.length || node2.rest) {
          this.tokenChar(44);
          this.space();
        }
      }
      this.printList(node2.params, node2);
      if (node2.rest) {
        if (node2.params.length) {
          this.tokenChar(44);
          this.space();
        }
        this.token("...");
        this.print(node2.rest, node2);
      }
      this.tokenChar(41);
      if (parent && (parent.type === "ObjectTypeCallProperty" || parent.type === "ObjectTypeInternalSlot" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method)) {
        this.tokenChar(58);
      } else {
        this.space();
        this.token("=>");
      }
      this.space();
      this.print(node2.returnType, node2);
    }
    function FunctionTypeParam(node2) {
      this.print(node2.name, node2);
      if (node2.optional)
        this.tokenChar(63);
      if (node2.name) {
        this.tokenChar(58);
        this.space();
      }
      this.print(node2.typeAnnotation, node2);
    }
    function InterfaceExtends(node2) {
      this.print(node2.id, node2);
      this.print(node2.typeParameters, node2, true);
    }
    function _interfaceish(node2) {
      var _node$extends;
      this.print(node2.id, node2);
      this.print(node2.typeParameters, node2);
      if ((_node$extends = node2.extends) != null && _node$extends.length) {
        this.space();
        this.word("extends");
        this.space();
        this.printList(node2.extends, node2);
      }
      if (node2.mixins && node2.mixins.length) {
        this.space();
        this.word("mixins");
        this.space();
        this.printList(node2.mixins, node2);
      }
      if (node2.implements && node2.implements.length) {
        this.space();
        this.word("implements");
        this.space();
        this.printList(node2.implements, node2);
      }
      this.space();
      this.print(node2.body, node2);
    }
    function _variance(node2) {
      if (node2.variance) {
        if (node2.variance.kind === "plus") {
          this.tokenChar(43);
        } else if (node2.variance.kind === "minus") {
          this.tokenChar(45);
        }
      }
    }
    function InterfaceDeclaration(node2) {
      this.word("interface");
      this.space();
      this._interfaceish(node2);
    }
    function andSeparator() {
      this.space();
      this.tokenChar(38);
      this.space();
    }
    function InterfaceTypeAnnotation(node2) {
      this.word("interface");
      if (node2.extends && node2.extends.length) {
        this.space();
        this.word("extends");
        this.space();
        this.printList(node2.extends, node2);
      }
      this.space();
      this.print(node2.body, node2);
    }
    function IntersectionTypeAnnotation(node2) {
      this.printJoin(node2.types, node2, {
        separator: andSeparator
      });
    }
    function MixedTypeAnnotation() {
      this.word("mixed");
    }
    function EmptyTypeAnnotation() {
      this.word("empty");
    }
    function NullableTypeAnnotation(node2) {
      this.tokenChar(63);
      this.print(node2.typeAnnotation, node2);
    }
    function NumberTypeAnnotation() {
      this.word("number");
    }
    function StringTypeAnnotation() {
      this.word("string");
    }
    function ThisTypeAnnotation() {
      this.word("this");
    }
    function TupleTypeAnnotation(node2) {
      this.tokenChar(91);
      this.printList(node2.types, node2);
      this.tokenChar(93);
    }
    function TypeofTypeAnnotation(node2) {
      this.word("typeof");
      this.space();
      this.print(node2.argument, node2);
    }
    function TypeAlias(node2) {
      this.word("type");
      this.space();
      this.print(node2.id, node2);
      this.print(node2.typeParameters, node2);
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node2.right, node2);
      this.semicolon();
    }
    function TypeAnnotation(node2) {
      this.tokenChar(58);
      this.space();
      if (node2.optional)
        this.tokenChar(63);
      this.print(node2.typeAnnotation, node2);
    }
    function TypeParameterInstantiation(node2) {
      this.tokenChar(60);
      this.printList(node2.params, node2, {});
      this.tokenChar(62);
    }
    function TypeParameter(node2) {
      this._variance(node2);
      this.word(node2.name);
      if (node2.bound) {
        this.print(node2.bound, node2);
      }
      if (node2.default) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.default, node2);
      }
    }
    function OpaqueType(node2) {
      this.word("opaque");
      this.space();
      this.word("type");
      this.space();
      this.print(node2.id, node2);
      this.print(node2.typeParameters, node2);
      if (node2.supertype) {
        this.tokenChar(58);
        this.space();
        this.print(node2.supertype, node2);
      }
      if (node2.impltype) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.impltype, node2);
      }
      this.semicolon();
    }
    function ObjectTypeAnnotation(node2) {
      if (node2.exact) {
        this.token("{|");
      } else {
        this.tokenChar(123);
      }
      const props = [...node2.properties, ...node2.callProperties || [], ...node2.indexers || [], ...node2.internalSlots || []];
      if (props.length) {
        this.newline();
        this.space();
        this.printJoin(props, node2, {
          addNewlines(leading) {
            if (leading && !props[0])
              return 1;
          },
          indent: true,
          statement: true,
          iterator: () => {
            if (props.length !== 1 || node2.inexact) {
              this.tokenChar(44);
              this.space();
            }
          }
        });
        this.space();
      }
      if (node2.inexact) {
        this.indent();
        this.token("...");
        if (props.length) {
          this.newline();
        }
        this.dedent();
      }
      if (node2.exact) {
        this.token("|}");
      } else {
        this.tokenChar(125);
      }
    }
    function ObjectTypeInternalSlot(node2) {
      if (node2.static) {
        this.word("static");
        this.space();
      }
      this.tokenChar(91);
      this.tokenChar(91);
      this.print(node2.id, node2);
      this.tokenChar(93);
      this.tokenChar(93);
      if (node2.optional)
        this.tokenChar(63);
      if (!node2.method) {
        this.tokenChar(58);
        this.space();
      }
      this.print(node2.value, node2);
    }
    function ObjectTypeCallProperty(node2) {
      if (node2.static) {
        this.word("static");
        this.space();
      }
      this.print(node2.value, node2);
    }
    function ObjectTypeIndexer(node2) {
      if (node2.static) {
        this.word("static");
        this.space();
      }
      this._variance(node2);
      this.tokenChar(91);
      if (node2.id) {
        this.print(node2.id, node2);
        this.tokenChar(58);
        this.space();
      }
      this.print(node2.key, node2);
      this.tokenChar(93);
      this.tokenChar(58);
      this.space();
      this.print(node2.value, node2);
    }
    function ObjectTypeProperty(node2) {
      if (node2.proto) {
        this.word("proto");
        this.space();
      }
      if (node2.static) {
        this.word("static");
        this.space();
      }
      if (node2.kind === "get" || node2.kind === "set") {
        this.word(node2.kind);
        this.space();
      }
      this._variance(node2);
      this.print(node2.key, node2);
      if (node2.optional)
        this.tokenChar(63);
      if (!node2.method) {
        this.tokenChar(58);
        this.space();
      }
      this.print(node2.value, node2);
    }
    function ObjectTypeSpreadProperty(node2) {
      this.token("...");
      this.print(node2.argument, node2);
    }
    function QualifiedTypeIdentifier(node2) {
      this.print(node2.qualification, node2);
      this.tokenChar(46);
      this.print(node2.id, node2);
    }
    function SymbolTypeAnnotation() {
      this.word("symbol");
    }
    function orSeparator() {
      this.space();
      this.tokenChar(124);
      this.space();
    }
    function UnionTypeAnnotation(node2) {
      this.printJoin(node2.types, node2, {
        separator: orSeparator
      });
    }
    function TypeCastExpression(node2) {
      this.tokenChar(40);
      this.print(node2.expression, node2);
      this.print(node2.typeAnnotation, node2);
      this.tokenChar(41);
    }
    function Variance(node2) {
      if (node2.kind === "plus") {
        this.tokenChar(43);
      } else {
        this.tokenChar(45);
      }
    }
    function VoidTypeAnnotation() {
      this.word("void");
    }
    function IndexedAccessType(node2) {
      this.print(node2.objectType, node2, true);
      this.tokenChar(91);
      this.print(node2.indexType, node2);
      this.tokenChar(93);
    }
    function OptionalIndexedAccessType(node2) {
      this.print(node2.objectType, node2);
      if (node2.optional) {
        this.token("?.");
      }
      this.tokenChar(91);
      this.print(node2.indexType, node2);
      this.tokenChar(93);
    }
  }
});

// node_modules/@babel/generator/lib/generators/base.js
var require_base = __commonJS({
  "node_modules/@babel/generator/lib/generators/base.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.BlockStatement = BlockStatement2;
    exports.Directive = Directive;
    exports.DirectiveLiteral = DirectiveLiteral;
    exports.File = File;
    exports.InterpreterDirective = InterpreterDirective;
    exports.Placeholder = Placeholder;
    exports.Program = Program;
    function File(node2) {
      if (node2.program) {
        this.print(node2.program.interpreter, node2);
      }
      this.print(node2.program, node2);
    }
    function Program(node2) {
      var _node$directives;
      this.noIndentInnerCommentsHere();
      this.printInnerComments();
      const directivesLen = (_node$directives = node2.directives) == null ? void 0 : _node$directives.length;
      if (directivesLen) {
        var _node$directives$trai;
        const newline = node2.body.length ? 2 : 1;
        this.printSequence(node2.directives, node2, {
          trailingCommentsLineOffset: newline
        });
        if (!((_node$directives$trai = node2.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai.length)) {
          this.newline(newline);
        }
      }
      this.printSequence(node2.body, node2);
    }
    function BlockStatement2(node2) {
      var _node$directives2;
      this.tokenChar(123);
      const directivesLen = (_node$directives2 = node2.directives) == null ? void 0 : _node$directives2.length;
      if (directivesLen) {
        var _node$directives$trai2;
        const newline = node2.body.length ? 2 : 1;
        this.printSequence(node2.directives, node2, {
          indent: true,
          trailingCommentsLineOffset: newline
        });
        if (!((_node$directives$trai2 = node2.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai2.length)) {
          this.newline(newline);
        }
      }
      this.printSequence(node2.body, node2, {
        indent: true
      });
      this.sourceWithOffset("end", node2.loc, 0, -1);
      this.rightBrace();
    }
    function Directive(node2) {
      this.print(node2.value, node2);
      this.semicolon();
    }
    var unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
    var unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
    function DirectiveLiteral(node2) {
      const raw = this.getPossibleRaw(node2);
      if (!this.format.minified && raw !== void 0) {
        this.token(raw);
        return;
      }
      const {
        value: value2
      } = node2;
      if (!unescapedDoubleQuoteRE.test(value2)) {
        this.token(`"${value2}"`);
      } else if (!unescapedSingleQuoteRE.test(value2)) {
        this.token(`'${value2}'`);
      } else {
        throw new Error("Malformed AST: it is not possible to print a directive containing both unescaped single and double quotes.");
      }
    }
    function InterpreterDirective(node2) {
      this.token(`#!${node2.value}`);
      this.newline(1, true);
    }
    function Placeholder(node2) {
      this.token("%%");
      this.print(node2.name);
      this.token("%%");
      if (node2.expectedNode === "Statement") {
        this.semicolon();
      }
    }
  }
});

// node_modules/@babel/generator/lib/generators/jsx.js
var require_jsx2 = __commonJS({
  "node_modules/@babel/generator/lib/generators/jsx.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.JSXAttribute = JSXAttribute2;
    exports.JSXClosingElement = JSXClosingElement2;
    exports.JSXClosingFragment = JSXClosingFragment2;
    exports.JSXElement = JSXElement2;
    exports.JSXEmptyExpression = JSXEmptyExpression2;
    exports.JSXExpressionContainer = JSXExpressionContainer2;
    exports.JSXFragment = JSXFragment2;
    exports.JSXIdentifier = JSXIdentifier2;
    exports.JSXMemberExpression = JSXMemberExpression2;
    exports.JSXNamespacedName = JSXNamespacedName2;
    exports.JSXOpeningElement = JSXOpeningElement2;
    exports.JSXOpeningFragment = JSXOpeningFragment2;
    exports.JSXSpreadAttribute = JSXSpreadAttribute2;
    exports.JSXSpreadChild = JSXSpreadChild;
    exports.JSXText = JSXText2;
    function JSXAttribute2(node2) {
      this.print(node2.name, node2);
      if (node2.value) {
        this.tokenChar(61);
        this.print(node2.value, node2);
      }
    }
    function JSXIdentifier2(node2) {
      this.word(node2.name);
    }
    function JSXNamespacedName2(node2) {
      this.print(node2.namespace, node2);
      this.tokenChar(58);
      this.print(node2.name, node2);
    }
    function JSXMemberExpression2(node2) {
      this.print(node2.object, node2);
      this.tokenChar(46);
      this.print(node2.property, node2);
    }
    function JSXSpreadAttribute2(node2) {
      this.tokenChar(123);
      this.token("...");
      this.print(node2.argument, node2);
      this.tokenChar(125);
    }
    function JSXExpressionContainer2(node2) {
      this.tokenChar(123);
      this.print(node2.expression, node2);
      this.tokenChar(125);
    }
    function JSXSpreadChild(node2) {
      this.tokenChar(123);
      this.token("...");
      this.print(node2.expression, node2);
      this.tokenChar(125);
    }
    function JSXText2(node2) {
      const raw = this.getPossibleRaw(node2);
      if (raw !== void 0) {
        this.token(raw, true);
      } else {
        this.token(node2.value, true);
      }
    }
    function JSXElement2(node2) {
      const open = node2.openingElement;
      this.print(open, node2);
      if (open.selfClosing)
        return;
      this.indent();
      for (const child of node2.children) {
        this.print(child, node2);
      }
      this.dedent();
      this.print(node2.closingElement, node2);
    }
    function spaceSeparator() {
      this.space();
    }
    function JSXOpeningElement2(node2) {
      this.tokenChar(60);
      this.print(node2.name, node2);
      this.print(node2.typeParameters, node2);
      if (node2.attributes.length > 0) {
        this.space();
        this.printJoin(node2.attributes, node2, {
          separator: spaceSeparator
        });
      }
      if (node2.selfClosing) {
        this.space();
        this.token("/>");
      } else {
        this.tokenChar(62);
      }
    }
    function JSXClosingElement2(node2) {
      this.token("</");
      this.print(node2.name, node2);
      this.tokenChar(62);
    }
    function JSXEmptyExpression2() {
      this.printInnerComments();
    }
    function JSXFragment2(node2) {
      this.print(node2.openingFragment, node2);
      this.indent();
      for (const child of node2.children) {
        this.print(child, node2);
      }
      this.dedent();
      this.print(node2.closingFragment, node2);
    }
    function JSXOpeningFragment2() {
      this.tokenChar(60);
      this.tokenChar(62);
    }
    function JSXClosingFragment2() {
      this.token("</");
      this.tokenChar(62);
    }
  }
});

// node_modules/@babel/generator/lib/generators/typescript.js
var require_typescript2 = __commonJS({
  "node_modules/@babel/generator/lib/generators/typescript.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.TSAnyKeyword = TSAnyKeyword;
    exports.TSArrayType = TSArrayType;
    exports.TSSatisfiesExpression = exports.TSAsExpression = TSTypeExpression;
    exports.TSBigIntKeyword = TSBigIntKeyword;
    exports.TSBooleanKeyword = TSBooleanKeyword;
    exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
    exports.TSConditionalType = TSConditionalType;
    exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
    exports.TSConstructorType = TSConstructorType;
    exports.TSDeclareFunction = TSDeclareFunction;
    exports.TSDeclareMethod = TSDeclareMethod;
    exports.TSEnumDeclaration = TSEnumDeclaration;
    exports.TSEnumMember = TSEnumMember;
    exports.TSExportAssignment = TSExportAssignment;
    exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
    exports.TSExternalModuleReference = TSExternalModuleReference;
    exports.TSFunctionType = TSFunctionType;
    exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
    exports.TSImportType = TSImportType;
    exports.TSIndexSignature = TSIndexSignature;
    exports.TSIndexedAccessType = TSIndexedAccessType;
    exports.TSInferType = TSInferType;
    exports.TSInstantiationExpression = TSInstantiationExpression;
    exports.TSInterfaceBody = TSInterfaceBody;
    exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
    exports.TSIntersectionType = TSIntersectionType;
    exports.TSIntrinsicKeyword = TSIntrinsicKeyword;
    exports.TSLiteralType = TSLiteralType;
    exports.TSMappedType = TSMappedType;
    exports.TSMethodSignature = TSMethodSignature;
    exports.TSModuleBlock = TSModuleBlock;
    exports.TSModuleDeclaration = TSModuleDeclaration;
    exports.TSNamedTupleMember = TSNamedTupleMember;
    exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
    exports.TSNeverKeyword = TSNeverKeyword;
    exports.TSNonNullExpression = TSNonNullExpression;
    exports.TSNullKeyword = TSNullKeyword;
    exports.TSNumberKeyword = TSNumberKeyword;
    exports.TSObjectKeyword = TSObjectKeyword;
    exports.TSOptionalType = TSOptionalType;
    exports.TSParameterProperty = TSParameterProperty;
    exports.TSParenthesizedType = TSParenthesizedType;
    exports.TSPropertySignature = TSPropertySignature;
    exports.TSQualifiedName = TSQualifiedName;
    exports.TSRestType = TSRestType;
    exports.TSStringKeyword = TSStringKeyword;
    exports.TSSymbolKeyword = TSSymbolKeyword;
    exports.TSThisType = TSThisType;
    exports.TSTupleType = TSTupleType;
    exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
    exports.TSTypeAnnotation = TSTypeAnnotation;
    exports.TSTypeAssertion = TSTypeAssertion;
    exports.TSTypeLiteral = TSTypeLiteral;
    exports.TSTypeOperator = TSTypeOperator;
    exports.TSTypeParameter = TSTypeParameter;
    exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
    exports.TSTypePredicate = TSTypePredicate;
    exports.TSTypeQuery = TSTypeQuery;
    exports.TSTypeReference = TSTypeReference;
    exports.TSUndefinedKeyword = TSUndefinedKeyword;
    exports.TSUnionType = TSUnionType;
    exports.TSUnknownKeyword = TSUnknownKeyword;
    exports.TSVoidKeyword = TSVoidKeyword;
    exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
    exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
    exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
    exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
    exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
    function TSTypeAnnotation(node2) {
      this.tokenChar(58);
      this.space();
      if (node2.optional)
        this.tokenChar(63);
      this.print(node2.typeAnnotation, node2);
    }
    function TSTypeParameterInstantiation(node2, parent) {
      this.tokenChar(60);
      this.printList(node2.params, node2, {});
      if (parent.type === "ArrowFunctionExpression" && node2.params.length === 1) {
        this.tokenChar(44);
      }
      this.tokenChar(62);
    }
    function TSTypeParameter(node2) {
      if (node2.in) {
        this.word("in");
        this.space();
      }
      if (node2.out) {
        this.word("out");
        this.space();
      }
      this.word(node2.name);
      if (node2.constraint) {
        this.space();
        this.word("extends");
        this.space();
        this.print(node2.constraint, node2);
      }
      if (node2.default) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(node2.default, node2);
      }
    }
    function TSParameterProperty(node2) {
      if (node2.accessibility) {
        this.word(node2.accessibility);
        this.space();
      }
      if (node2.readonly) {
        this.word("readonly");
        this.space();
      }
      this._param(node2.parameter);
    }
    function TSDeclareFunction(node2, parent) {
      if (node2.declare) {
        this.word("declare");
        this.space();
      }
      this._functionHead(node2, parent);
      this.tokenChar(59);
    }
    function TSDeclareMethod(node2) {
      this._classMethodHead(node2);
      this.tokenChar(59);
    }
    function TSQualifiedName(node2) {
      this.print(node2.left, node2);
      this.tokenChar(46);
      this.print(node2.right, node2);
    }
    function TSCallSignatureDeclaration(node2) {
      this.tsPrintSignatureDeclarationBase(node2);
      this.tokenChar(59);
    }
    function TSConstructSignatureDeclaration(node2) {
      this.word("new");
      this.space();
      this.tsPrintSignatureDeclarationBase(node2);
      this.tokenChar(59);
    }
    function TSPropertySignature(node2) {
      const {
        readonly,
        initializer
      } = node2;
      if (readonly) {
        this.word("readonly");
        this.space();
      }
      this.tsPrintPropertyOrMethodName(node2);
      this.print(node2.typeAnnotation, node2);
      if (initializer) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(initializer, node2);
      }
      this.tokenChar(59);
    }
    function tsPrintPropertyOrMethodName(node2) {
      if (node2.computed) {
        this.tokenChar(91);
      }
      this.print(node2.key, node2);
      if (node2.computed) {
        this.tokenChar(93);
      }
      if (node2.optional) {
        this.tokenChar(63);
      }
    }
    function TSMethodSignature(node2) {
      const {
        kind
      } = node2;
      if (kind === "set" || kind === "get") {
        this.word(kind);
        this.space();
      }
      this.tsPrintPropertyOrMethodName(node2);
      this.tsPrintSignatureDeclarationBase(node2);
      this.tokenChar(59);
    }
    function TSIndexSignature(node2) {
      const {
        readonly,
        static: isStatic
      } = node2;
      if (isStatic) {
        this.word("static");
        this.space();
      }
      if (readonly) {
        this.word("readonly");
        this.space();
      }
      this.tokenChar(91);
      this._parameters(node2.parameters, node2);
      this.tokenChar(93);
      this.print(node2.typeAnnotation, node2);
      this.tokenChar(59);
    }
    function TSAnyKeyword() {
      this.word("any");
    }
    function TSBigIntKeyword() {
      this.word("bigint");
    }
    function TSUnknownKeyword() {
      this.word("unknown");
    }
    function TSNumberKeyword() {
      this.word("number");
    }
    function TSObjectKeyword() {
      this.word("object");
    }
    function TSBooleanKeyword() {
      this.word("boolean");
    }
    function TSStringKeyword() {
      this.word("string");
    }
    function TSSymbolKeyword() {
      this.word("symbol");
    }
    function TSVoidKeyword() {
      this.word("void");
    }
    function TSUndefinedKeyword() {
      this.word("undefined");
    }
    function TSNullKeyword() {
      this.word("null");
    }
    function TSNeverKeyword() {
      this.word("never");
    }
    function TSIntrinsicKeyword() {
      this.word("intrinsic");
    }
    function TSThisType() {
      this.word("this");
    }
    function TSFunctionType(node2) {
      this.tsPrintFunctionOrConstructorType(node2);
    }
    function TSConstructorType(node2) {
      if (node2.abstract) {
        this.word("abstract");
        this.space();
      }
      this.word("new");
      this.space();
      this.tsPrintFunctionOrConstructorType(node2);
    }
    function tsPrintFunctionOrConstructorType(node2) {
      const {
        typeParameters
      } = node2;
      const parameters = node2.parameters;
      this.print(typeParameters, node2);
      this.tokenChar(40);
      this._parameters(parameters, node2);
      this.tokenChar(41);
      this.space();
      this.token("=>");
      this.space();
      const returnType = node2.typeAnnotation;
      this.print(returnType.typeAnnotation, node2);
    }
    function TSTypeReference(node2) {
      this.print(node2.typeName, node2, true);
      this.print(node2.typeParameters, node2, true);
    }
    function TSTypePredicate(node2) {
      if (node2.asserts) {
        this.word("asserts");
        this.space();
      }
      this.print(node2.parameterName);
      if (node2.typeAnnotation) {
        this.space();
        this.word("is");
        this.space();
        this.print(node2.typeAnnotation.typeAnnotation);
      }
    }
    function TSTypeQuery(node2) {
      this.word("typeof");
      this.space();
      this.print(node2.exprName);
      if (node2.typeParameters) {
        this.print(node2.typeParameters, node2);
      }
    }
    function TSTypeLiteral(node2) {
      this.tsPrintTypeLiteralOrInterfaceBody(node2.members, node2);
    }
    function tsPrintTypeLiteralOrInterfaceBody(members, node2) {
      tsPrintBraced(this, members, node2);
    }
    function tsPrintBraced(printer, members, node2) {
      printer.token("{");
      if (members.length) {
        printer.indent();
        printer.newline();
        for (const member of members) {
          printer.print(member, node2);
          printer.newline();
        }
        printer.dedent();
      }
      printer.sourceWithOffset("end", node2.loc, 0, -1);
      printer.rightBrace();
    }
    function TSArrayType(node2) {
      this.print(node2.elementType, node2, true);
      this.token("[]");
    }
    function TSTupleType(node2) {
      this.tokenChar(91);
      this.printList(node2.elementTypes, node2);
      this.tokenChar(93);
    }
    function TSOptionalType(node2) {
      this.print(node2.typeAnnotation, node2);
      this.tokenChar(63);
    }
    function TSRestType(node2) {
      this.token("...");
      this.print(node2.typeAnnotation, node2);
    }
    function TSNamedTupleMember(node2) {
      this.print(node2.label, node2);
      if (node2.optional)
        this.tokenChar(63);
      this.tokenChar(58);
      this.space();
      this.print(node2.elementType, node2);
    }
    function TSUnionType(node2) {
      tsPrintUnionOrIntersectionType(this, node2, "|");
    }
    function TSIntersectionType(node2) {
      tsPrintUnionOrIntersectionType(this, node2, "&");
    }
    function tsPrintUnionOrIntersectionType(printer, node2, sep) {
      printer.printJoin(node2.types, node2, {
        separator() {
          this.space();
          this.token(sep);
          this.space();
        }
      });
    }
    function TSConditionalType(node2) {
      this.print(node2.checkType);
      this.space();
      this.word("extends");
      this.space();
      this.print(node2.extendsType);
      this.space();
      this.tokenChar(63);
      this.space();
      this.print(node2.trueType);
      this.space();
      this.tokenChar(58);
      this.space();
      this.print(node2.falseType);
    }
    function TSInferType(node2) {
      this.token("infer");
      this.space();
      this.print(node2.typeParameter);
    }
    function TSParenthesizedType(node2) {
      this.tokenChar(40);
      this.print(node2.typeAnnotation, node2);
      this.tokenChar(41);
    }
    function TSTypeOperator(node2) {
      this.word(node2.operator);
      this.space();
      this.print(node2.typeAnnotation, node2);
    }
    function TSIndexedAccessType(node2) {
      this.print(node2.objectType, node2, true);
      this.tokenChar(91);
      this.print(node2.indexType, node2);
      this.tokenChar(93);
    }
    function TSMappedType(node2) {
      const {
        nameType,
        optional,
        readonly,
        typeParameter
      } = node2;
      this.tokenChar(123);
      this.space();
      if (readonly) {
        tokenIfPlusMinus(this, readonly);
        this.word("readonly");
        this.space();
      }
      this.tokenChar(91);
      this.word(typeParameter.name);
      this.space();
      this.word("in");
      this.space();
      this.print(typeParameter.constraint, typeParameter);
      if (nameType) {
        this.space();
        this.word("as");
        this.space();
        this.print(nameType, node2);
      }
      this.tokenChar(93);
      if (optional) {
        tokenIfPlusMinus(this, optional);
        this.tokenChar(63);
      }
      this.tokenChar(58);
      this.space();
      this.print(node2.typeAnnotation, node2);
      this.space();
      this.tokenChar(125);
    }
    function tokenIfPlusMinus(self2, tok) {
      if (tok !== true) {
        self2.token(tok);
      }
    }
    function TSLiteralType(node2) {
      this.print(node2.literal, node2);
    }
    function TSExpressionWithTypeArguments(node2) {
      this.print(node2.expression, node2);
      this.print(node2.typeParameters, node2);
    }
    function TSInterfaceDeclaration(node2) {
      const {
        declare,
        id,
        typeParameters,
        extends: extendz,
        body
      } = node2;
      if (declare) {
        this.word("declare");
        this.space();
      }
      this.word("interface");
      this.space();
      this.print(id, node2);
      this.print(typeParameters, node2);
      if (extendz != null && extendz.length) {
        this.space();
        this.word("extends");
        this.space();
        this.printList(extendz, node2);
      }
      this.space();
      this.print(body, node2);
    }
    function TSInterfaceBody(node2) {
      this.tsPrintTypeLiteralOrInterfaceBody(node2.body, node2);
    }
    function TSTypeAliasDeclaration(node2) {
      const {
        declare,
        id,
        typeParameters,
        typeAnnotation
      } = node2;
      if (declare) {
        this.word("declare");
        this.space();
      }
      this.word("type");
      this.space();
      this.print(id, node2);
      this.print(typeParameters, node2);
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(typeAnnotation, node2);
      this.tokenChar(59);
    }
    function TSTypeExpression(node2) {
      var _expression$trailingC;
      const {
        type,
        expression,
        typeAnnotation
      } = node2;
      const forceParens = !!((_expression$trailingC = expression.trailingComments) != null && _expression$trailingC.length);
      this.print(expression, node2, true, void 0, forceParens);
      this.space();
      this.word(type === "TSAsExpression" ? "as" : "satisfies");
      this.space();
      this.print(typeAnnotation, node2);
    }
    function TSTypeAssertion(node2) {
      const {
        typeAnnotation,
        expression
      } = node2;
      this.tokenChar(60);
      this.print(typeAnnotation, node2);
      this.tokenChar(62);
      this.space();
      this.print(expression, node2);
    }
    function TSInstantiationExpression(node2) {
      this.print(node2.expression, node2);
      this.print(node2.typeParameters, node2);
    }
    function TSEnumDeclaration(node2) {
      const {
        declare,
        const: isConst,
        id,
        members
      } = node2;
      if (declare) {
        this.word("declare");
        this.space();
      }
      if (isConst) {
        this.word("const");
        this.space();
      }
      this.word("enum");
      this.space();
      this.print(id, node2);
      this.space();
      tsPrintBraced(this, members, node2);
    }
    function TSEnumMember(node2) {
      const {
        id,
        initializer
      } = node2;
      this.print(id, node2);
      if (initializer) {
        this.space();
        this.tokenChar(61);
        this.space();
        this.print(initializer, node2);
      }
      this.tokenChar(44);
    }
    function TSModuleDeclaration(node2) {
      const {
        declare,
        id
      } = node2;
      if (declare) {
        this.word("declare");
        this.space();
      }
      if (!node2.global) {
        this.word(id.type === "Identifier" ? "namespace" : "module");
        this.space();
      }
      this.print(id, node2);
      if (!node2.body) {
        this.tokenChar(59);
        return;
      }
      let body = node2.body;
      while (body.type === "TSModuleDeclaration") {
        this.tokenChar(46);
        this.print(body.id, body);
        body = body.body;
      }
      this.space();
      this.print(body, node2);
    }
    function TSModuleBlock(node2) {
      tsPrintBraced(this, node2.body, node2);
    }
    function TSImportType(node2) {
      const {
        argument,
        qualifier,
        typeParameters
      } = node2;
      this.word("import");
      this.tokenChar(40);
      this.print(argument, node2);
      this.tokenChar(41);
      if (qualifier) {
        this.tokenChar(46);
        this.print(qualifier, node2);
      }
      if (typeParameters) {
        this.print(typeParameters, node2);
      }
    }
    function TSImportEqualsDeclaration(node2) {
      const {
        isExport,
        id,
        moduleReference
      } = node2;
      if (isExport) {
        this.word("export");
        this.space();
      }
      this.word("import");
      this.space();
      this.print(id, node2);
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(moduleReference, node2);
      this.tokenChar(59);
    }
    function TSExternalModuleReference(node2) {
      this.token("require(");
      this.print(node2.expression, node2);
      this.tokenChar(41);
    }
    function TSNonNullExpression(node2) {
      this.print(node2.expression, node2);
      this.tokenChar(33);
    }
    function TSExportAssignment(node2) {
      this.word("export");
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node2.expression, node2);
      this.tokenChar(59);
    }
    function TSNamespaceExportDeclaration(node2) {
      this.word("export");
      this.space();
      this.word("as");
      this.space();
      this.word("namespace");
      this.space();
      this.print(node2.id, node2);
    }
    function tsPrintSignatureDeclarationBase(node2) {
      const {
        typeParameters
      } = node2;
      const parameters = node2.parameters;
      this.print(typeParameters, node2);
      this.tokenChar(40);
      this._parameters(parameters, node2);
      this.tokenChar(41);
      const returnType = node2.typeAnnotation;
      this.print(returnType, node2);
    }
    function tsPrintClassMemberModifiers(node2) {
      const isField = node2.type === "ClassAccessorProperty" || node2.type === "ClassProperty";
      if (isField && node2.declare) {
        this.word("declare");
        this.space();
      }
      if (node2.accessibility) {
        this.word(node2.accessibility);
        this.space();
      }
      if (node2.static) {
        this.word("static");
        this.space();
      }
      if (node2.override) {
        this.word("override");
        this.space();
      }
      if (node2.abstract) {
        this.word("abstract");
        this.space();
      }
      if (isField && node2.readonly) {
        this.word("readonly");
        this.space();
      }
    }
  }
});

// node_modules/@babel/generator/lib/generators/index.js
var require_generators = __commonJS({
  "node_modules/@babel/generator/lib/generators/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    var _templateLiterals = require_template_literals();
    Object.keys(_templateLiterals).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _templateLiterals[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _templateLiterals[key2];
        }
      });
    });
    var _expressions = require_expressions();
    Object.keys(_expressions).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _expressions[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _expressions[key2];
        }
      });
    });
    var _statements = require_statements();
    Object.keys(_statements).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _statements[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _statements[key2];
        }
      });
    });
    var _classes = require_classes();
    Object.keys(_classes).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _classes[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _classes[key2];
        }
      });
    });
    var _methods = require_methods();
    Object.keys(_methods).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _methods[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _methods[key2];
        }
      });
    });
    var _modules = require_modules();
    Object.keys(_modules).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _modules[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _modules[key2];
        }
      });
    });
    var _types = require_types();
    Object.keys(_types).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _types[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _types[key2];
        }
      });
    });
    var _flow = require_flow2();
    Object.keys(_flow).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _flow[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _flow[key2];
        }
      });
    });
    var _base = require_base();
    Object.keys(_base).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _base[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _base[key2];
        }
      });
    });
    var _jsx = require_jsx2();
    Object.keys(_jsx).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _jsx[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _jsx[key2];
        }
      });
    });
    var _typescript = require_typescript2();
    Object.keys(_typescript).forEach(function(key2) {
      if (key2 === "default" || key2 === "__esModule")
        return;
      if (key2 in exports && exports[key2] === _typescript[key2])
        return;
      Object.defineProperty(exports, key2, {
        enumerable: true,
        get: function() {
          return _typescript[key2];
        }
      });
    });
  }
});

// node_modules/@babel/generator/lib/printer.js
var require_printer = __commonJS({
  "node_modules/@babel/generator/lib/printer.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _buffer = require_buffer();
    var n = require_node();
    var _t = require_lib3();
    var generatorFunctions = require_generators();
    require_trace_mapping_umd();
    var {
      isFunction,
      isStatement,
      isClassBody,
      isTSInterfaceBody,
      isTSEnumDeclaration
    } = _t;
    var SCIENTIFIC_NOTATION = /e/i;
    var ZERO_DECIMAL_INTEGER = /\.0+$/;
    var NON_DECIMAL_LITERAL = /^0[box]/;
    var PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
    var HAS_NEWLINE = /[\n\r\u2028\u2029]/;
    var HAS_BlOCK_COMMENT_END = /\*\//;
    var {
      needsParens
    } = n;
    var Printer = class {
      constructor(format, map) {
        this.inForStatementInitCounter = 0;
        this._printStack = [];
        this._indent = 0;
        this._indentChar = 0;
        this._indentRepeat = 0;
        this._insideAux = false;
        this._parenPushNewlineState = null;
        this._noLineTerminator = false;
        this._printAuxAfterOnNextUserNode = false;
        this._printedComments = /* @__PURE__ */ new Set();
        this._endsWithInteger = false;
        this._endsWithWord = false;
        this._lastCommentLine = 0;
        this._endsWithInnerRaw = false;
        this._indentInnerComments = true;
        this.format = format;
        this._buf = new _buffer.default(map);
        this._indentChar = format.indent.style.charCodeAt(0);
        this._indentRepeat = format.indent.style.length;
        this._inputMap = map == null ? void 0 : map._inputMap;
      }
      generate(ast) {
        this.print(ast);
        this._maybeAddAuxComment();
        return this._buf.get();
      }
      indent() {
        if (this.format.compact || this.format.concise)
          return;
        this._indent++;
      }
      dedent() {
        if (this.format.compact || this.format.concise)
          return;
        this._indent--;
      }
      semicolon(force = false) {
        this._maybeAddAuxComment();
        if (force) {
          this._appendChar(59);
        } else {
          this._queue(59);
        }
        this._noLineTerminator = false;
      }
      rightBrace() {
        if (this.format.minified) {
          this._buf.removeLastSemicolon();
        }
        this.tokenChar(125);
      }
      space(force = false) {
        if (this.format.compact)
          return;
        if (force) {
          this._space();
        } else if (this._buf.hasContent()) {
          const lastCp = this.getLastChar();
          if (lastCp !== 32 && lastCp !== 10) {
            this._space();
          }
        }
      }
      word(str, noLineTerminatorAfter = false) {
        this._maybePrintInnerComments();
        if (this._endsWithWord || str.charCodeAt(0) === 47 && this.endsWith(47)) {
          this._space();
        }
        this._maybeAddAuxComment();
        this._append(str, false);
        this._endsWithWord = true;
        this._noLineTerminator = noLineTerminatorAfter;
      }
      number(str) {
        this.word(str);
        this._endsWithInteger = Number.isInteger(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
      }
      token(str, maybeNewline = false) {
        this._maybePrintInnerComments();
        const lastChar = this.getLastChar();
        const strFirst = str.charCodeAt(0);
        if (lastChar === 33 && (str === "--" || strFirst === 61) || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) {
          this._space();
        }
        this._maybeAddAuxComment();
        this._append(str, maybeNewline);
        this._noLineTerminator = false;
      }
      tokenChar(char) {
        this._maybePrintInnerComments();
        const lastChar = this.getLastChar();
        if (char === 43 && lastChar === 43 || char === 45 && lastChar === 45 || char === 46 && this._endsWithInteger) {
          this._space();
        }
        this._maybeAddAuxComment();
        this._appendChar(char);
        this._noLineTerminator = false;
      }
      newline(i = 1, force) {
        if (i <= 0)
          return;
        if (!force) {
          if (this.format.retainLines || this.format.compact)
            return;
          if (this.format.concise) {
            this.space();
            return;
          }
        }
        if (i > 2)
          i = 2;
        i -= this._buf.getNewlineCount();
        for (let j = 0; j < i; j++) {
          this._newline();
        }
        return;
      }
      endsWith(char) {
        return this.getLastChar() === char;
      }
      getLastChar() {
        return this._buf.getLastChar();
      }
      endsWithCharAndNewline() {
        return this._buf.endsWithCharAndNewline();
      }
      removeTrailingNewline() {
        this._buf.removeTrailingNewline();
      }
      exactSource(loc, cb) {
        if (!loc) {
          cb();
          return;
        }
        this._catchUp("start", loc);
        this._buf.exactSource(loc, cb);
      }
      source(prop, loc) {
        if (!loc)
          return;
        this._catchUp(prop, loc);
        this._buf.source(prop, loc);
      }
      sourceWithOffset(prop, loc, lineOffset, columnOffset) {
        if (!loc)
          return;
        this._catchUp(prop, loc);
        this._buf.sourceWithOffset(prop, loc, lineOffset, columnOffset);
      }
      withSource(prop, loc, cb) {
        if (!loc) {
          cb();
          return;
        }
        this._catchUp(prop, loc);
        this._buf.withSource(prop, loc, cb);
      }
      sourceIdentifierName(identifierName, pos2) {
        if (!this._buf._canMarkIdName)
          return;
        const sourcePosition = this._buf._sourcePosition;
        sourcePosition.identifierNamePos = pos2;
        sourcePosition.identifierName = identifierName;
      }
      _space() {
        this._queue(32);
      }
      _newline() {
        this._queue(10);
      }
      _append(str, maybeNewline) {
        this._maybeAddParen(str);
        this._maybeIndent(str.charCodeAt(0));
        this._buf.append(str, maybeNewline);
        this._endsWithWord = false;
        this._endsWithInteger = false;
      }
      _appendChar(char) {
        this._maybeAddParenChar(char);
        this._maybeIndent(char);
        this._buf.appendChar(char);
        this._endsWithWord = false;
        this._endsWithInteger = false;
      }
      _queue(char) {
        this._maybeAddParenChar(char);
        this._maybeIndent(char);
        this._buf.queue(char);
        this._endsWithWord = false;
        this._endsWithInteger = false;
      }
      _maybeIndent(firstChar) {
        if (this._indent && firstChar !== 10 && this.endsWith(10)) {
          this._buf.queueIndentation(this._indentChar, this._getIndent());
        }
      }
      _shouldIndent(firstChar) {
        if (this._indent && firstChar !== 10 && this.endsWith(10)) {
          return true;
        }
      }
      _maybeAddParenChar(char) {
        const parenPushNewlineState = this._parenPushNewlineState;
        if (!parenPushNewlineState)
          return;
        if (char === 32) {
          return;
        }
        if (char !== 10) {
          this._parenPushNewlineState = null;
          return;
        }
        this.tokenChar(40);
        this.indent();
        parenPushNewlineState.printed = true;
      }
      _maybeAddParen(str) {
        const parenPushNewlineState = this._parenPushNewlineState;
        if (!parenPushNewlineState)
          return;
        const len = str.length;
        let i;
        for (i = 0; i < len && str.charCodeAt(i) === 32; i++)
          continue;
        if (i === len) {
          return;
        }
        const cha = str.charCodeAt(i);
        if (cha !== 10) {
          if (cha !== 47 || i + 1 === len) {
            this._parenPushNewlineState = null;
            return;
          }
          const chaPost = str.charCodeAt(i + 1);
          if (chaPost === 42) {
            if (PURE_ANNOTATION_RE.test(str.slice(i + 2, len - 2))) {
              return;
            }
          } else if (chaPost !== 47) {
            this._parenPushNewlineState = null;
            return;
          }
        }
        this.tokenChar(40);
        this.indent();
        parenPushNewlineState.printed = true;
      }
      catchUp(line2) {
        if (!this.format.retainLines)
          return;
        const count = line2 - this._buf.getCurrentLine();
        for (let i = 0; i < count; i++) {
          this._newline();
        }
      }
      _catchUp(prop, loc) {
        if (!this.format.retainLines)
          return;
        const pos2 = loc ? loc[prop] : null;
        if ((pos2 == null ? void 0 : pos2.line) != null) {
          const count = pos2.line - this._buf.getCurrentLine();
          for (let i = 0; i < count; i++) {
            this._newline();
          }
        }
      }
      _getIndent() {
        return this._indentRepeat * this._indent;
      }
      printTerminatorless(node2, parent, isLabel) {
        if (isLabel) {
          this._noLineTerminator = true;
          this.print(node2, parent);
        } else {
          const terminatorState = {
            printed: false
          };
          this._parenPushNewlineState = terminatorState;
          this.print(node2, parent);
          if (terminatorState.printed) {
            this.dedent();
            this.newline();
            this.tokenChar(41);
          }
        }
      }
      print(node2, parent, noLineTerminatorAfter, trailingCommentsLineOffset, forceParens) {
        if (!node2)
          return;
        this._endsWithInnerRaw = false;
        const nodeType = node2.type;
        const format = this.format;
        const oldConcise = format.concise;
        if (node2._compact) {
          format.concise = true;
        }
        const printMethod = this[nodeType];
        if (printMethod === void 0) {
          throw new ReferenceError(`unknown node of type ${JSON.stringify(nodeType)} with constructor ${JSON.stringify(node2.constructor.name)}`);
        }
        this._printStack.push(node2);
        const oldInAux = this._insideAux;
        this._insideAux = node2.loc == void 0;
        this._maybeAddAuxComment(this._insideAux && !oldInAux);
        let shouldPrintParens = false;
        if (forceParens) {
          shouldPrintParens = true;
        } else if (format.retainFunctionParens && nodeType === "FunctionExpression" && node2.extra && node2.extra.parenthesized) {
          shouldPrintParens = true;
        } else {
          shouldPrintParens = needsParens(node2, parent, this._printStack);
        }
        if (shouldPrintParens) {
          this.tokenChar(40);
          this._endsWithInnerRaw = false;
        }
        this._lastCommentLine = 0;
        this._printLeadingComments(node2, parent);
        const loc = nodeType === "Program" || nodeType === "File" ? null : node2.loc;
        this.exactSource(loc, printMethod.bind(this, node2, parent));
        if (shouldPrintParens) {
          this._printTrailingComments(node2, parent);
          this.tokenChar(41);
          this._noLineTerminator = noLineTerminatorAfter;
        } else if (noLineTerminatorAfter && !this._noLineTerminator) {
          this._noLineTerminator = true;
          this._printTrailingComments(node2, parent);
        } else {
          this._printTrailingComments(node2, parent, trailingCommentsLineOffset);
        }
        this._printStack.pop();
        format.concise = oldConcise;
        this._insideAux = oldInAux;
        this._endsWithInnerRaw = false;
      }
      _maybeAddAuxComment(enteredPositionlessNode) {
        if (enteredPositionlessNode)
          this._printAuxBeforeComment();
        if (!this._insideAux)
          this._printAuxAfterComment();
      }
      _printAuxBeforeComment() {
        if (this._printAuxAfterOnNextUserNode)
          return;
        this._printAuxAfterOnNextUserNode = true;
        const comment2 = this.format.auxiliaryCommentBefore;
        if (comment2) {
          this._printComment({
            type: "CommentBlock",
            value: comment2
          }, 0);
        }
      }
      _printAuxAfterComment() {
        if (!this._printAuxAfterOnNextUserNode)
          return;
        this._printAuxAfterOnNextUserNode = false;
        const comment2 = this.format.auxiliaryCommentAfter;
        if (comment2) {
          this._printComment({
            type: "CommentBlock",
            value: comment2
          }, 0);
        }
      }
      getPossibleRaw(node2) {
        const extra = node2.extra;
        if (extra && extra.raw != null && extra.rawValue != null && node2.value === extra.rawValue) {
          return extra.raw;
        }
      }
      printJoin(nodes, parent, opts = {}) {
        if (!(nodes != null && nodes.length))
          return;
        if (opts.indent)
          this.indent();
        const newlineOpts = {
          addNewlines: opts.addNewlines,
          nextNodeStartLine: 0
        };
        const separator = opts.separator ? opts.separator.bind(this) : null;
        const len = nodes.length;
        for (let i = 0; i < len; i++) {
          const node2 = nodes[i];
          if (!node2)
            continue;
          if (opts.statement)
            this._printNewline(i === 0, newlineOpts);
          this.print(node2, parent, void 0, opts.trailingCommentsLineOffset || 0);
          opts.iterator == null ? void 0 : opts.iterator(node2, i);
          if (i < len - 1)
            separator == null ? void 0 : separator();
          if (opts.statement) {
            if (i + 1 === len) {
              this.newline(1);
            } else {
              var _nextNode$loc;
              const nextNode = nodes[i + 1];
              newlineOpts.nextNodeStartLine = ((_nextNode$loc = nextNode.loc) == null ? void 0 : _nextNode$loc.start.line) || 0;
              this._printNewline(true, newlineOpts);
            }
          }
        }
        if (opts.indent)
          this.dedent();
      }
      printAndIndentOnComments(node2, parent) {
        const indent = node2.leadingComments && node2.leadingComments.length > 0;
        if (indent)
          this.indent();
        this.print(node2, parent);
        if (indent)
          this.dedent();
      }
      printBlock(parent) {
        const node2 = parent.body;
        if (node2.type !== "EmptyStatement") {
          this.space();
        }
        this.print(node2, parent);
      }
      _printTrailingComments(node2, parent, lineOffset) {
        const {
          innerComments,
          trailingComments
        } = node2;
        if (innerComments != null && innerComments.length) {
          this._printComments(2, innerComments, node2, parent, lineOffset);
        }
        if (trailingComments != null && trailingComments.length) {
          this._printComments(2, trailingComments, node2, parent, lineOffset);
        }
      }
      _printLeadingComments(node2, parent) {
        const comments = node2.leadingComments;
        if (!(comments != null && comments.length))
          return;
        this._printComments(0, comments, node2, parent);
      }
      _maybePrintInnerComments() {
        if (this._endsWithInnerRaw)
          this.printInnerComments();
        this._endsWithInnerRaw = true;
        this._indentInnerComments = true;
      }
      printInnerComments() {
        const node2 = this._printStack[this._printStack.length - 1];
        const comments = node2.innerComments;
        if (!(comments != null && comments.length))
          return;
        const hasSpace = this.endsWith(32);
        const indent = this._indentInnerComments;
        const printedCommentsCount = this._printedComments.size;
        if (indent)
          this.indent();
        this._printComments(1, comments, node2);
        if (hasSpace && printedCommentsCount !== this._printedComments.size) {
          this.space();
        }
        if (indent)
          this.dedent();
      }
      noIndentInnerCommentsHere() {
        this._indentInnerComments = false;
      }
      printSequence(nodes, parent, opts = {}) {
        opts.statement = true;
        this.printJoin(nodes, parent, opts);
      }
      printList(items, parent, opts = {}) {
        if (opts.separator == null) {
          opts.separator = commaSeparator;
        }
        this.printJoin(items, parent, opts);
      }
      _printNewline(newLine, opts) {
        if (this.format.retainLines || this.format.compact)
          return;
        if (this.format.concise) {
          this.space();
          return;
        }
        if (!newLine) {
          return;
        }
        const startLine = opts.nextNodeStartLine;
        const lastCommentLine = this._lastCommentLine;
        if (startLine > 0 && lastCommentLine > 0) {
          const offset3 = startLine - lastCommentLine;
          if (offset3 >= 0) {
            this.newline(offset3 || 1);
            return;
          }
        }
        if (this._buf.hasContent()) {
          this.newline(1);
        }
      }
      _shouldPrintComment(comment2) {
        if (comment2.ignore)
          return 0;
        if (this._printedComments.has(comment2))
          return 0;
        if (this._noLineTerminator && (HAS_NEWLINE.test(comment2.value) || HAS_BlOCK_COMMENT_END.test(comment2.value))) {
          return 2;
        }
        this._printedComments.add(comment2);
        if (!this.format.shouldPrintComment(comment2.value)) {
          return 0;
        }
        return 1;
      }
      _printComment(comment2, skipNewLines) {
        const noLineTerminator = this._noLineTerminator;
        const isBlockComment = comment2.type === "CommentBlock";
        const printNewLines = isBlockComment && skipNewLines !== 1 && !this._noLineTerminator;
        if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) {
          this.newline(1);
        }
        const lastCharCode = this.getLastChar();
        if (lastCharCode !== 91 && lastCharCode !== 123) {
          this.space();
        }
        let val;
        if (isBlockComment) {
          val = `/*${comment2.value}*/`;
          if (this.format.indent.adjustMultilineComment) {
            var _comment$loc;
            const offset3 = (_comment$loc = comment2.loc) == null ? void 0 : _comment$loc.start.column;
            if (offset3) {
              const newlineRegex = new RegExp("\\n\\s{1," + offset3 + "}", "g");
              val = val.replace(newlineRegex, "\n");
            }
            let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
            if (this._shouldIndent(47) || this.format.retainLines) {
              indentSize += this._getIndent();
            }
            val = val.replace(/\n(?!$)/g, `
${" ".repeat(indentSize)}`);
          }
        } else if (!noLineTerminator) {
          val = `//${comment2.value}`;
        } else {
          val = `/*${comment2.value}*/`;
        }
        if (this.endsWith(47))
          this._space();
        this.source("start", comment2.loc);
        this._append(val, isBlockComment);
        if (!isBlockComment && !noLineTerminator) {
          this.newline(1, true);
        }
        if (printNewLines && skipNewLines !== 3) {
          this.newline(1);
        }
      }
      _printComments(type, comments, node2, parent, lineOffset = 0) {
        const nodeLoc = node2.loc;
        const len = comments.length;
        let hasLoc = !!nodeLoc;
        const nodeStartLine = hasLoc ? nodeLoc.start.line : 0;
        const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
        let lastLine = 0;
        let leadingCommentNewline = 0;
        const maybeNewline = this._noLineTerminator ? function() {
        } : this.newline.bind(this);
        for (let i = 0; i < len; i++) {
          const comment2 = comments[i];
          const shouldPrint = this._shouldPrintComment(comment2);
          if (shouldPrint === 2) {
            hasLoc = false;
            break;
          }
          if (hasLoc && comment2.loc && shouldPrint === 1) {
            const commentStartLine = comment2.loc.start.line;
            const commentEndLine = comment2.loc.end.line;
            if (type === 0) {
              let offset3 = 0;
              if (i === 0) {
                if (this._buf.hasContent() && (comment2.type === "CommentLine" || commentStartLine != commentEndLine)) {
                  offset3 = leadingCommentNewline = 1;
                }
              } else {
                offset3 = commentStartLine - lastLine;
              }
              lastLine = commentEndLine;
              maybeNewline(offset3);
              this._printComment(comment2, 1);
              if (i + 1 === len) {
                maybeNewline(Math.max(nodeStartLine - lastLine, leadingCommentNewline));
                lastLine = nodeStartLine;
              }
            } else if (type === 1) {
              const offset3 = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
              lastLine = commentEndLine;
              maybeNewline(offset3);
              this._printComment(comment2, 1);
              if (i + 1 === len) {
                maybeNewline(Math.min(1, nodeEndLine - lastLine));
                lastLine = nodeEndLine;
              }
            } else {
              const offset3 = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
              lastLine = commentEndLine;
              maybeNewline(offset3);
              this._printComment(comment2, 1);
            }
          } else {
            hasLoc = false;
            if (shouldPrint !== 1) {
              continue;
            }
            if (len === 1) {
              const singleLine = comment2.loc ? comment2.loc.start.line === comment2.loc.end.line : !HAS_NEWLINE.test(comment2.value);
              const shouldSkipNewline = singleLine && !isStatement(node2) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumDeclaration(parent);
              if (type === 0) {
                this._printComment(comment2, shouldSkipNewline && node2.type !== "ObjectExpression" || singleLine && isFunction(parent, {
                  body: node2
                }) ? 1 : 0);
              } else if (shouldSkipNewline && type === 2) {
                this._printComment(comment2, 1);
              } else {
                this._printComment(comment2, 0);
              }
            } else if (type === 1 && !(node2.type === "ObjectExpression" && node2.properties.length > 1) && node2.type !== "ClassBody" && node2.type !== "TSInterfaceBody") {
              this._printComment(comment2, i === 0 ? 2 : i === len - 1 ? 3 : 0);
            } else {
              this._printComment(comment2, 0);
            }
          }
        }
        if (type === 2 && hasLoc && lastLine) {
          this._lastCommentLine = lastLine;
        }
      }
    };
    Object.assign(Printer.prototype, generatorFunctions);
    {
      Printer.prototype.Noop = function Noop() {
      };
    }
    var _default = Printer;
    exports.default = _default;
    function commaSeparator() {
      this.tokenChar(44);
      this.space();
    }
  }
});

// node_modules/@babel/generator/lib/index.js
var require_lib4 = __commonJS({
  "node_modules/@babel/generator/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.CodeGenerator = void 0;
    exports.default = generate5;
    var _sourceMap = require_source_map();
    var _printer = require_printer();
    var Generator = class extends _printer.default {
      constructor(ast, opts = {}, code2) {
        const format = normalizeOptions(code2, opts);
        const map = opts.sourceMaps ? new _sourceMap.default(opts, code2) : null;
        super(format, map);
        this.ast = void 0;
        this.ast = ast;
      }
      generate() {
        return super.generate(this.ast);
      }
    };
    function normalizeOptions(code2, opts) {
      const format = {
        auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
        auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
        shouldPrintComment: opts.shouldPrintComment,
        retainLines: opts.retainLines,
        retainFunctionParens: opts.retainFunctionParens,
        comments: opts.comments == null || opts.comments,
        compact: opts.compact,
        minified: opts.minified,
        concise: opts.concise,
        indent: {
          adjustMultilineComment: true,
          style: "  "
        },
        jsescOption: Object.assign({
          quotes: "double",
          wrap: true,
          minimal: false
        }, opts.jsescOption),
        recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType,
        topicToken: opts.topicToken
      };
      {
        format.decoratorsBeforeExport = opts.decoratorsBeforeExport;
        format.jsescOption.json = opts.jsonCompatibleStrings;
      }
      if (format.minified) {
        format.compact = true;
        format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
      } else {
        format.shouldPrintComment = format.shouldPrintComment || ((value2) => format.comments || value2.includes("@license") || value2.includes("@preserve"));
      }
      if (format.compact === "auto") {
        format.compact = typeof code2 === "string" && code2.length > 5e5;
        if (format.compact) {
          console.error(`[BABEL] Note: The code generator has deoptimised the styling of ${opts.filename} as it exceeds the max of ${"500KB"}.`);
        }
      }
      if (format.compact) {
        format.indent.adjustMultilineComment = false;
      }
      const {
        auxiliaryCommentBefore,
        auxiliaryCommentAfter,
        shouldPrintComment
      } = format;
      if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) {
        format.auxiliaryCommentBefore = void 0;
      }
      if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) {
        format.auxiliaryCommentAfter = void 0;
      }
      return format;
    }
    var CodeGenerator = class {
      constructor(ast, opts, code2) {
        this._generator = void 0;
        this._generator = new Generator(ast, opts, code2);
      }
      generate() {
        return this._generator.generate();
      }
    };
    exports.CodeGenerator = CodeGenerator;
    function generate5(ast, opts, code2) {
      const gen = new Generator(ast, opts, code2);
      return gen.generate();
    }
  }
});

// node_modules/lodash/_listCacheClear.js
var require_listCacheClear = __commonJS({
  "node_modules/lodash/_listCacheClear.js"(exports, module2) {
    function listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }
    module2.exports = listCacheClear;
  }
});

// node_modules/lodash/eq.js
var require_eq = __commonJS({
  "node_modules/lodash/eq.js"(exports, module2) {
    function eq(value2, other) {
      return value2 === other || value2 !== value2 && other !== other;
    }
    module2.exports = eq;
  }
});

// node_modules/lodash/_assocIndexOf.js
var require_assocIndexOf = __commonJS({
  "node_modules/lodash/_assocIndexOf.js"(exports, module2) {
    var eq = require_eq();
    function assocIndexOf(array, key2) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key2)) {
          return length;
        }
      }
      return -1;
    }
    module2.exports = assocIndexOf;
  }
});

// node_modules/lodash/_listCacheDelete.js
var require_listCacheDelete = __commonJS({
  "node_modules/lodash/_listCacheDelete.js"(exports, module2) {
    var assocIndexOf = require_assocIndexOf();
    var arrayProto = Array.prototype;
    var splice2 = arrayProto.splice;
    function listCacheDelete(key2) {
      var data3 = this.__data__, index2 = assocIndexOf(data3, key2);
      if (index2 < 0) {
        return false;
      }
      var lastIndex = data3.length - 1;
      if (index2 == lastIndex) {
        data3.pop();
      } else {
        splice2.call(data3, index2, 1);
      }
      --this.size;
      return true;
    }
    module2.exports = listCacheDelete;
  }
});

// node_modules/lodash/_listCacheGet.js
var require_listCacheGet = __commonJS({
  "node_modules/lodash/_listCacheGet.js"(exports, module2) {
    var assocIndexOf = require_assocIndexOf();
    function listCacheGet(key2) {
      var data3 = this.__data__, index2 = assocIndexOf(data3, key2);
      return index2 < 0 ? void 0 : data3[index2][1];
    }
    module2.exports = listCacheGet;
  }
});

// node_modules/lodash/_listCacheHas.js
var require_listCacheHas = __commonJS({
  "node_modules/lodash/_listCacheHas.js"(exports, module2) {
    var assocIndexOf = require_assocIndexOf();
    function listCacheHas(key2) {
      return assocIndexOf(this.__data__, key2) > -1;
    }
    module2.exports = listCacheHas;
  }
});

// node_modules/lodash/_listCacheSet.js
var require_listCacheSet = __commonJS({
  "node_modules/lodash/_listCacheSet.js"(exports, module2) {
    var assocIndexOf = require_assocIndexOf();
    function listCacheSet(key2, value2) {
      var data3 = this.__data__, index2 = assocIndexOf(data3, key2);
      if (index2 < 0) {
        ++this.size;
        data3.push([key2, value2]);
      } else {
        data3[index2][1] = value2;
      }
      return this;
    }
    module2.exports = listCacheSet;
  }
});

// node_modules/lodash/_ListCache.js
var require_ListCache = __commonJS({
  "node_modules/lodash/_ListCache.js"(exports, module2) {
    var listCacheClear = require_listCacheClear();
    var listCacheDelete = require_listCacheDelete();
    var listCacheGet = require_listCacheGet();
    var listCacheHas = require_listCacheHas();
    var listCacheSet = require_listCacheSet();
    function ListCache(entries) {
      var index2 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index2 < length) {
        var entry = entries[index2];
        this.set(entry[0], entry[1]);
      }
    }
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    module2.exports = ListCache;
  }
});

// node_modules/lodash/_stackClear.js
var require_stackClear = __commonJS({
  "node_modules/lodash/_stackClear.js"(exports, module2) {
    var ListCache = require_ListCache();
    function stackClear() {
      this.__data__ = new ListCache();
      this.size = 0;
    }
    module2.exports = stackClear;
  }
});

// node_modules/lodash/_stackDelete.js
var require_stackDelete = __commonJS({
  "node_modules/lodash/_stackDelete.js"(exports, module2) {
    function stackDelete(key2) {
      var data3 = this.__data__, result = data3["delete"](key2);
      this.size = data3.size;
      return result;
    }
    module2.exports = stackDelete;
  }
});

// node_modules/lodash/_stackGet.js
var require_stackGet = __commonJS({
  "node_modules/lodash/_stackGet.js"(exports, module2) {
    function stackGet(key2) {
      return this.__data__.get(key2);
    }
    module2.exports = stackGet;
  }
});

// node_modules/lodash/_stackHas.js
var require_stackHas = __commonJS({
  "node_modules/lodash/_stackHas.js"(exports, module2) {
    function stackHas(key2) {
      return this.__data__.has(key2);
    }
    module2.exports = stackHas;
  }
});

// node_modules/lodash/_freeGlobal.js
var require_freeGlobal = __commonJS({
  "node_modules/lodash/_freeGlobal.js"(exports, module2) {
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    module2.exports = freeGlobal;
  }
});

// node_modules/lodash/_root.js
var require_root = __commonJS({
  "node_modules/lodash/_root.js"(exports, module2) {
    var freeGlobal = require_freeGlobal();
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root4 = freeGlobal || freeSelf || Function("return this")();
    module2.exports = root4;
  }
});

// node_modules/lodash/_Symbol.js
var require_Symbol = __commonJS({
  "node_modules/lodash/_Symbol.js"(exports, module2) {
    var root4 = require_root();
    var Symbol2 = root4.Symbol;
    module2.exports = Symbol2;
  }
});

// node_modules/lodash/_getRawTag.js
var require_getRawTag = __commonJS({
  "node_modules/lodash/_getRawTag.js"(exports, module2) {
    var Symbol2 = require_Symbol();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    var nativeObjectToString = objectProto.toString;
    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
    function getRawTag(value2) {
      var isOwn = hasOwnProperty4.call(value2, symToStringTag), tag = value2[symToStringTag];
      try {
        value2[symToStringTag] = void 0;
        var unmasked = true;
      } catch (e) {
      }
      var result = nativeObjectToString.call(value2);
      if (unmasked) {
        if (isOwn) {
          value2[symToStringTag] = tag;
        } else {
          delete value2[symToStringTag];
        }
      }
      return result;
    }
    module2.exports = getRawTag;
  }
});

// node_modules/lodash/_objectToString.js
var require_objectToString = __commonJS({
  "node_modules/lodash/_objectToString.js"(exports, module2) {
    var objectProto = Object.prototype;
    var nativeObjectToString = objectProto.toString;
    function objectToString(value2) {
      return nativeObjectToString.call(value2);
    }
    module2.exports = objectToString;
  }
});

// node_modules/lodash/_baseGetTag.js
var require_baseGetTag = __commonJS({
  "node_modules/lodash/_baseGetTag.js"(exports, module2) {
    var Symbol2 = require_Symbol();
    var getRawTag = require_getRawTag();
    var objectToString = require_objectToString();
    var nullTag = "[object Null]";
    var undefinedTag = "[object Undefined]";
    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
    function baseGetTag(value2) {
      if (value2 == null) {
        return value2 === void 0 ? undefinedTag : nullTag;
      }
      return symToStringTag && symToStringTag in Object(value2) ? getRawTag(value2) : objectToString(value2);
    }
    module2.exports = baseGetTag;
  }
});

// node_modules/lodash/isObject.js
var require_isObject = __commonJS({
  "node_modules/lodash/isObject.js"(exports, module2) {
    function isObject(value2) {
      var type = typeof value2;
      return value2 != null && (type == "object" || type == "function");
    }
    module2.exports = isObject;
  }
});

// node_modules/lodash/isFunction.js
var require_isFunction = __commonJS({
  "node_modules/lodash/isFunction.js"(exports, module2) {
    var baseGetTag = require_baseGetTag();
    var isObject = require_isObject();
    var asyncTag = "[object AsyncFunction]";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var proxyTag = "[object Proxy]";
    function isFunction(value2) {
      if (!isObject(value2)) {
        return false;
      }
      var tag = baseGetTag(value2);
      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
    }
    module2.exports = isFunction;
  }
});

// node_modules/lodash/_coreJsData.js
var require_coreJsData = __commonJS({
  "node_modules/lodash/_coreJsData.js"(exports, module2) {
    var root4 = require_root();
    var coreJsData = root4["__core-js_shared__"];
    module2.exports = coreJsData;
  }
});

// node_modules/lodash/_isMasked.js
var require_isMasked = __commonJS({
  "node_modules/lodash/_isMasked.js"(exports, module2) {
    var coreJsData = require_coreJsData();
    var maskSrcKey = function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    }();
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    module2.exports = isMasked;
  }
});

// node_modules/lodash/_toSource.js
var require_toSource = __commonJS({
  "node_modules/lodash/_toSource.js"(exports, module2) {
    var funcProto = Function.prototype;
    var funcToString = funcProto.toString;
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {
        }
        try {
          return func + "";
        } catch (e) {
        }
      }
      return "";
    }
    module2.exports = toSource;
  }
});

// node_modules/lodash/_baseIsNative.js
var require_baseIsNative = __commonJS({
  "node_modules/lodash/_baseIsNative.js"(exports, module2) {
    var isFunction = require_isFunction();
    var isMasked = require_isMasked();
    var isObject = require_isObject();
    var toSource = require_toSource();
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var funcToString = funcProto.toString;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    var reIsNative = RegExp(
      "^" + funcToString.call(hasOwnProperty4).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
    );
    function baseIsNative(value2) {
      if (!isObject(value2) || isMasked(value2)) {
        return false;
      }
      var pattern = isFunction(value2) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value2));
    }
    module2.exports = baseIsNative;
  }
});

// node_modules/lodash/_getValue.js
var require_getValue = __commonJS({
  "node_modules/lodash/_getValue.js"(exports, module2) {
    function getValue(object, key2) {
      return object == null ? void 0 : object[key2];
    }
    module2.exports = getValue;
  }
});

// node_modules/lodash/_getNative.js
var require_getNative = __commonJS({
  "node_modules/lodash/_getNative.js"(exports, module2) {
    var baseIsNative = require_baseIsNative();
    var getValue = require_getValue();
    function getNative(object, key2) {
      var value2 = getValue(object, key2);
      return baseIsNative(value2) ? value2 : void 0;
    }
    module2.exports = getNative;
  }
});

// node_modules/lodash/_Map.js
var require_Map = __commonJS({
  "node_modules/lodash/_Map.js"(exports, module2) {
    var getNative = require_getNative();
    var root4 = require_root();
    var Map2 = getNative(root4, "Map");
    module2.exports = Map2;
  }
});

// node_modules/lodash/_nativeCreate.js
var require_nativeCreate = __commonJS({
  "node_modules/lodash/_nativeCreate.js"(exports, module2) {
    var getNative = require_getNative();
    var nativeCreate = getNative(Object, "create");
    module2.exports = nativeCreate;
  }
});

// node_modules/lodash/_hashClear.js
var require_hashClear = __commonJS({
  "node_modules/lodash/_hashClear.js"(exports, module2) {
    var nativeCreate = require_nativeCreate();
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
      this.size = 0;
    }
    module2.exports = hashClear;
  }
});

// node_modules/lodash/_hashDelete.js
var require_hashDelete = __commonJS({
  "node_modules/lodash/_hashDelete.js"(exports, module2) {
    function hashDelete(key2) {
      var result = this.has(key2) && delete this.__data__[key2];
      this.size -= result ? 1 : 0;
      return result;
    }
    module2.exports = hashDelete;
  }
});

// node_modules/lodash/_hashGet.js
var require_hashGet = __commonJS({
  "node_modules/lodash/_hashGet.js"(exports, module2) {
    var nativeCreate = require_nativeCreate();
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function hashGet(key2) {
      var data3 = this.__data__;
      if (nativeCreate) {
        var result = data3[key2];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty4.call(data3, key2) ? data3[key2] : void 0;
    }
    module2.exports = hashGet;
  }
});

// node_modules/lodash/_hashHas.js
var require_hashHas = __commonJS({
  "node_modules/lodash/_hashHas.js"(exports, module2) {
    var nativeCreate = require_nativeCreate();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function hashHas(key2) {
      var data3 = this.__data__;
      return nativeCreate ? data3[key2] !== void 0 : hasOwnProperty4.call(data3, key2);
    }
    module2.exports = hashHas;
  }
});

// node_modules/lodash/_hashSet.js
var require_hashSet = __commonJS({
  "node_modules/lodash/_hashSet.js"(exports, module2) {
    var nativeCreate = require_nativeCreate();
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    function hashSet(key2, value2) {
      var data3 = this.__data__;
      this.size += this.has(key2) ? 0 : 1;
      data3[key2] = nativeCreate && value2 === void 0 ? HASH_UNDEFINED : value2;
      return this;
    }
    module2.exports = hashSet;
  }
});

// node_modules/lodash/_Hash.js
var require_Hash = __commonJS({
  "node_modules/lodash/_Hash.js"(exports, module2) {
    var hashClear = require_hashClear();
    var hashDelete = require_hashDelete();
    var hashGet = require_hashGet();
    var hashHas = require_hashHas();
    var hashSet = require_hashSet();
    function Hash(entries) {
      var index2 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index2 < length) {
        var entry = entries[index2];
        this.set(entry[0], entry[1]);
      }
    }
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    module2.exports = Hash;
  }
});

// node_modules/lodash/_mapCacheClear.js
var require_mapCacheClear = __commonJS({
  "node_modules/lodash/_mapCacheClear.js"(exports, module2) {
    var Hash = require_Hash();
    var ListCache = require_ListCache();
    var Map2 = require_Map();
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    module2.exports = mapCacheClear;
  }
});

// node_modules/lodash/_isKeyable.js
var require_isKeyable = __commonJS({
  "node_modules/lodash/_isKeyable.js"(exports, module2) {
    function isKeyable(value2) {
      var type = typeof value2;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value2 !== "__proto__" : value2 === null;
    }
    module2.exports = isKeyable;
  }
});

// node_modules/lodash/_getMapData.js
var require_getMapData = __commonJS({
  "node_modules/lodash/_getMapData.js"(exports, module2) {
    var isKeyable = require_isKeyable();
    function getMapData(map, key2) {
      var data3 = map.__data__;
      return isKeyable(key2) ? data3[typeof key2 == "string" ? "string" : "hash"] : data3.map;
    }
    module2.exports = getMapData;
  }
});

// node_modules/lodash/_mapCacheDelete.js
var require_mapCacheDelete = __commonJS({
  "node_modules/lodash/_mapCacheDelete.js"(exports, module2) {
    var getMapData = require_getMapData();
    function mapCacheDelete(key2) {
      var result = getMapData(this, key2)["delete"](key2);
      this.size -= result ? 1 : 0;
      return result;
    }
    module2.exports = mapCacheDelete;
  }
});

// node_modules/lodash/_mapCacheGet.js
var require_mapCacheGet = __commonJS({
  "node_modules/lodash/_mapCacheGet.js"(exports, module2) {
    var getMapData = require_getMapData();
    function mapCacheGet(key2) {
      return getMapData(this, key2).get(key2);
    }
    module2.exports = mapCacheGet;
  }
});

// node_modules/lodash/_mapCacheHas.js
var require_mapCacheHas = __commonJS({
  "node_modules/lodash/_mapCacheHas.js"(exports, module2) {
    var getMapData = require_getMapData();
    function mapCacheHas(key2) {
      return getMapData(this, key2).has(key2);
    }
    module2.exports = mapCacheHas;
  }
});

// node_modules/lodash/_mapCacheSet.js
var require_mapCacheSet = __commonJS({
  "node_modules/lodash/_mapCacheSet.js"(exports, module2) {
    var getMapData = require_getMapData();
    function mapCacheSet(key2, value2) {
      var data3 = getMapData(this, key2), size = data3.size;
      data3.set(key2, value2);
      this.size += data3.size == size ? 0 : 1;
      return this;
    }
    module2.exports = mapCacheSet;
  }
});

// node_modules/lodash/_MapCache.js
var require_MapCache = __commonJS({
  "node_modules/lodash/_MapCache.js"(exports, module2) {
    var mapCacheClear = require_mapCacheClear();
    var mapCacheDelete = require_mapCacheDelete();
    var mapCacheGet = require_mapCacheGet();
    var mapCacheHas = require_mapCacheHas();
    var mapCacheSet = require_mapCacheSet();
    function MapCache(entries) {
      var index2 = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index2 < length) {
        var entry = entries[index2];
        this.set(entry[0], entry[1]);
      }
    }
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    module2.exports = MapCache;
  }
});

// node_modules/lodash/_stackSet.js
var require_stackSet = __commonJS({
  "node_modules/lodash/_stackSet.js"(exports, module2) {
    var ListCache = require_ListCache();
    var Map2 = require_Map();
    var MapCache = require_MapCache();
    var LARGE_ARRAY_SIZE = 200;
    function stackSet(key2, value2) {
      var data3 = this.__data__;
      if (data3 instanceof ListCache) {
        var pairs = data3.__data__;
        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
          pairs.push([key2, value2]);
          this.size = ++data3.size;
          return this;
        }
        data3 = this.__data__ = new MapCache(pairs);
      }
      data3.set(key2, value2);
      this.size = data3.size;
      return this;
    }
    module2.exports = stackSet;
  }
});

// node_modules/lodash/_Stack.js
var require_Stack = __commonJS({
  "node_modules/lodash/_Stack.js"(exports, module2) {
    var ListCache = require_ListCache();
    var stackClear = require_stackClear();
    var stackDelete = require_stackDelete();
    var stackGet = require_stackGet();
    var stackHas = require_stackHas();
    var stackSet = require_stackSet();
    function Stack(entries) {
      var data3 = this.__data__ = new ListCache(entries);
      this.size = data3.size;
    }
    Stack.prototype.clear = stackClear;
    Stack.prototype["delete"] = stackDelete;
    Stack.prototype.get = stackGet;
    Stack.prototype.has = stackHas;
    Stack.prototype.set = stackSet;
    module2.exports = Stack;
  }
});

// node_modules/lodash/_arrayEach.js
var require_arrayEach = __commonJS({
  "node_modules/lodash/_arrayEach.js"(exports, module2) {
    function arrayEach(array, iteratee) {
      var index2 = -1, length = array == null ? 0 : array.length;
      while (++index2 < length) {
        if (iteratee(array[index2], index2, array) === false) {
          break;
        }
      }
      return array;
    }
    module2.exports = arrayEach;
  }
});

// node_modules/lodash/_defineProperty.js
var require_defineProperty = __commonJS({
  "node_modules/lodash/_defineProperty.js"(exports, module2) {
    var getNative = require_getNative();
    var defineProperty = function() {
      try {
        var func = getNative(Object, "defineProperty");
        func({}, "", {});
        return func;
      } catch (e) {
      }
    }();
    module2.exports = defineProperty;
  }
});

// node_modules/lodash/_baseAssignValue.js
var require_baseAssignValue = __commonJS({
  "node_modules/lodash/_baseAssignValue.js"(exports, module2) {
    var defineProperty = require_defineProperty();
    function baseAssignValue(object, key2, value2) {
      if (key2 == "__proto__" && defineProperty) {
        defineProperty(object, key2, {
          "configurable": true,
          "enumerable": true,
          "value": value2,
          "writable": true
        });
      } else {
        object[key2] = value2;
      }
    }
    module2.exports = baseAssignValue;
  }
});

// node_modules/lodash/_assignValue.js
var require_assignValue = __commonJS({
  "node_modules/lodash/_assignValue.js"(exports, module2) {
    var baseAssignValue = require_baseAssignValue();
    var eq = require_eq();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function assignValue(object, key2, value2) {
      var objValue = object[key2];
      if (!(hasOwnProperty4.call(object, key2) && eq(objValue, value2)) || value2 === void 0 && !(key2 in object)) {
        baseAssignValue(object, key2, value2);
      }
    }
    module2.exports = assignValue;
  }
});

// node_modules/lodash/_copyObject.js
var require_copyObject = __commonJS({
  "node_modules/lodash/_copyObject.js"(exports, module2) {
    var assignValue = require_assignValue();
    var baseAssignValue = require_baseAssignValue();
    function copyObject(source2, props, object, customizer) {
      var isNew = !object;
      object || (object = {});
      var index2 = -1, length = props.length;
      while (++index2 < length) {
        var key2 = props[index2];
        var newValue = customizer ? customizer(object[key2], source2[key2], key2, object, source2) : void 0;
        if (newValue === void 0) {
          newValue = source2[key2];
        }
        if (isNew) {
          baseAssignValue(object, key2, newValue);
        } else {
          assignValue(object, key2, newValue);
        }
      }
      return object;
    }
    module2.exports = copyObject;
  }
});

// node_modules/lodash/_baseTimes.js
var require_baseTimes = __commonJS({
  "node_modules/lodash/_baseTimes.js"(exports, module2) {
    function baseTimes(n, iteratee) {
      var index2 = -1, result = Array(n);
      while (++index2 < n) {
        result[index2] = iteratee(index2);
      }
      return result;
    }
    module2.exports = baseTimes;
  }
});

// node_modules/lodash/isObjectLike.js
var require_isObjectLike = __commonJS({
  "node_modules/lodash/isObjectLike.js"(exports, module2) {
    function isObjectLike(value2) {
      return value2 != null && typeof value2 == "object";
    }
    module2.exports = isObjectLike;
  }
});

// node_modules/lodash/_baseIsArguments.js
var require_baseIsArguments = __commonJS({
  "node_modules/lodash/_baseIsArguments.js"(exports, module2) {
    var baseGetTag = require_baseGetTag();
    var isObjectLike = require_isObjectLike();
    var argsTag = "[object Arguments]";
    function baseIsArguments(value2) {
      return isObjectLike(value2) && baseGetTag(value2) == argsTag;
    }
    module2.exports = baseIsArguments;
  }
});

// node_modules/lodash/isArguments.js
var require_isArguments = __commonJS({
  "node_modules/lodash/isArguments.js"(exports, module2) {
    var baseIsArguments = require_baseIsArguments();
    var isObjectLike = require_isObjectLike();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
    var isArguments = baseIsArguments(function() {
      return arguments;
    }()) ? baseIsArguments : function(value2) {
      return isObjectLike(value2) && hasOwnProperty4.call(value2, "callee") && !propertyIsEnumerable.call(value2, "callee");
    };
    module2.exports = isArguments;
  }
});

// node_modules/lodash/isArray.js
var require_isArray = __commonJS({
  "node_modules/lodash/isArray.js"(exports, module2) {
    var isArray3 = Array.isArray;
    module2.exports = isArray3;
  }
});

// node_modules/lodash/stubFalse.js
var require_stubFalse = __commonJS({
  "node_modules/lodash/stubFalse.js"(exports, module2) {
    function stubFalse() {
      return false;
    }
    module2.exports = stubFalse;
  }
});

// node_modules/lodash/isBuffer.js
var require_isBuffer = __commonJS({
  "node_modules/lodash/isBuffer.js"(exports, module2) {
    var root4 = require_root();
    var stubFalse = require_stubFalse();
    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var Buffer2 = moduleExports ? root4.Buffer : void 0;
    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
    var isBuffer2 = nativeIsBuffer || stubFalse;
    module2.exports = isBuffer2;
  }
});

// node_modules/lodash/_isIndex.js
var require_isIndex = __commonJS({
  "node_modules/lodash/_isIndex.js"(exports, module2) {
    var MAX_SAFE_INTEGER = 9007199254740991;
    var reIsUint = /^(?:0|[1-9]\d*)$/;
    function isIndex(value2, length) {
      var type = typeof value2;
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length && (type == "number" || type != "symbol" && reIsUint.test(value2)) && (value2 > -1 && value2 % 1 == 0 && value2 < length);
    }
    module2.exports = isIndex;
  }
});

// node_modules/lodash/isLength.js
var require_isLength = __commonJS({
  "node_modules/lodash/isLength.js"(exports, module2) {
    var MAX_SAFE_INTEGER = 9007199254740991;
    function isLength(value2) {
      return typeof value2 == "number" && value2 > -1 && value2 % 1 == 0 && value2 <= MAX_SAFE_INTEGER;
    }
    module2.exports = isLength;
  }
});

// node_modules/lodash/_baseIsTypedArray.js
var require_baseIsTypedArray = __commonJS({
  "node_modules/lodash/_baseIsTypedArray.js"(exports, module2) {
    var baseGetTag = require_baseGetTag();
    var isLength = require_isLength();
    var isObjectLike = require_isObjectLike();
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var errorTag = "[object Error]";
    var funcTag = "[object Function]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var objectTag = "[object Object]";
    var regexpTag = "[object RegExp]";
    var setTag = "[object Set]";
    var stringTag = "[object String]";
    var weakMapTag = "[object WeakMap]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    var typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
    function baseIsTypedArray(value2) {
      return isObjectLike(value2) && isLength(value2.length) && !!typedArrayTags[baseGetTag(value2)];
    }
    module2.exports = baseIsTypedArray;
  }
});

// node_modules/lodash/_baseUnary.js
var require_baseUnary = __commonJS({
  "node_modules/lodash/_baseUnary.js"(exports, module2) {
    function baseUnary(func) {
      return function(value2) {
        return func(value2);
      };
    }
    module2.exports = baseUnary;
  }
});

// node_modules/lodash/_nodeUtil.js
var require_nodeUtil = __commonJS({
  "node_modules/lodash/_nodeUtil.js"(exports, module2) {
    var freeGlobal = require_freeGlobal();
    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var freeProcess = moduleExports && freeGlobal.process;
    var nodeUtil = function() {
      try {
        var types3 = freeModule && freeModule.require && freeModule.require("util").types;
        if (types3) {
          return types3;
        }
        return freeProcess && freeProcess.binding && freeProcess.binding("util");
      } catch (e) {
      }
    }();
    module2.exports = nodeUtil;
  }
});

// node_modules/lodash/isTypedArray.js
var require_isTypedArray = __commonJS({
  "node_modules/lodash/isTypedArray.js"(exports, module2) {
    var baseIsTypedArray = require_baseIsTypedArray();
    var baseUnary = require_baseUnary();
    var nodeUtil = require_nodeUtil();
    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
    module2.exports = isTypedArray;
  }
});

// node_modules/lodash/_arrayLikeKeys.js
var require_arrayLikeKeys = __commonJS({
  "node_modules/lodash/_arrayLikeKeys.js"(exports, module2) {
    var baseTimes = require_baseTimes();
    var isArguments = require_isArguments();
    var isArray3 = require_isArray();
    var isBuffer2 = require_isBuffer();
    var isIndex = require_isIndex();
    var isTypedArray = require_isTypedArray();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function arrayLikeKeys(value2, inherited) {
      var isArr = isArray3(value2), isArg = !isArr && isArguments(value2), isBuff = !isArr && !isArg && isBuffer2(value2), isType = !isArr && !isArg && !isBuff && isTypedArray(value2), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value2.length, String) : [], length = result.length;
      for (var key2 in value2) {
        if ((inherited || hasOwnProperty4.call(value2, key2)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
        (key2 == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
        isBuff && (key2 == "offset" || key2 == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
        isType && (key2 == "buffer" || key2 == "byteLength" || key2 == "byteOffset") || // Skip index properties.
        isIndex(key2, length)))) {
          result.push(key2);
        }
      }
      return result;
    }
    module2.exports = arrayLikeKeys;
  }
});

// node_modules/lodash/_isPrototype.js
var require_isPrototype = __commonJS({
  "node_modules/lodash/_isPrototype.js"(exports, module2) {
    var objectProto = Object.prototype;
    function isPrototype(value2) {
      var Ctor = value2 && value2.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
      return value2 === proto;
    }
    module2.exports = isPrototype;
  }
});

// node_modules/lodash/_overArg.js
var require_overArg = __commonJS({
  "node_modules/lodash/_overArg.js"(exports, module2) {
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }
    module2.exports = overArg;
  }
});

// node_modules/lodash/_nativeKeys.js
var require_nativeKeys = __commonJS({
  "node_modules/lodash/_nativeKeys.js"(exports, module2) {
    var overArg = require_overArg();
    var nativeKeys = overArg(Object.keys, Object);
    module2.exports = nativeKeys;
  }
});

// node_modules/lodash/_baseKeys.js
var require_baseKeys = __commonJS({
  "node_modules/lodash/_baseKeys.js"(exports, module2) {
    var isPrototype = require_isPrototype();
    var nativeKeys = require_nativeKeys();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key2 in Object(object)) {
        if (hasOwnProperty4.call(object, key2) && key2 != "constructor") {
          result.push(key2);
        }
      }
      return result;
    }
    module2.exports = baseKeys;
  }
});

// node_modules/lodash/isArrayLike.js
var require_isArrayLike = __commonJS({
  "node_modules/lodash/isArrayLike.js"(exports, module2) {
    var isFunction = require_isFunction();
    var isLength = require_isLength();
    function isArrayLike(value2) {
      return value2 != null && isLength(value2.length) && !isFunction(value2);
    }
    module2.exports = isArrayLike;
  }
});

// node_modules/lodash/keys.js
var require_keys = __commonJS({
  "node_modules/lodash/keys.js"(exports, module2) {
    var arrayLikeKeys = require_arrayLikeKeys();
    var baseKeys = require_baseKeys();
    var isArrayLike = require_isArrayLike();
    function keys2(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }
    module2.exports = keys2;
  }
});

// node_modules/lodash/_baseAssign.js
var require_baseAssign = __commonJS({
  "node_modules/lodash/_baseAssign.js"(exports, module2) {
    var copyObject = require_copyObject();
    var keys2 = require_keys();
    function baseAssign(object, source2) {
      return object && copyObject(source2, keys2(source2), object);
    }
    module2.exports = baseAssign;
  }
});

// node_modules/lodash/_nativeKeysIn.js
var require_nativeKeysIn = __commonJS({
  "node_modules/lodash/_nativeKeysIn.js"(exports, module2) {
    function nativeKeysIn(object) {
      var result = [];
      if (object != null) {
        for (var key2 in Object(object)) {
          result.push(key2);
        }
      }
      return result;
    }
    module2.exports = nativeKeysIn;
  }
});

// node_modules/lodash/_baseKeysIn.js
var require_baseKeysIn = __commonJS({
  "node_modules/lodash/_baseKeysIn.js"(exports, module2) {
    var isObject = require_isObject();
    var isPrototype = require_isPrototype();
    var nativeKeysIn = require_nativeKeysIn();
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function baseKeysIn(object) {
      if (!isObject(object)) {
        return nativeKeysIn(object);
      }
      var isProto = isPrototype(object), result = [];
      for (var key2 in object) {
        if (!(key2 == "constructor" && (isProto || !hasOwnProperty4.call(object, key2)))) {
          result.push(key2);
        }
      }
      return result;
    }
    module2.exports = baseKeysIn;
  }
});

// node_modules/lodash/keysIn.js
var require_keysIn = __commonJS({
  "node_modules/lodash/keysIn.js"(exports, module2) {
    var arrayLikeKeys = require_arrayLikeKeys();
    var baseKeysIn = require_baseKeysIn();
    var isArrayLike = require_isArrayLike();
    function keysIn(object) {
      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
    }
    module2.exports = keysIn;
  }
});

// node_modules/lodash/_baseAssignIn.js
var require_baseAssignIn = __commonJS({
  "node_modules/lodash/_baseAssignIn.js"(exports, module2) {
    var copyObject = require_copyObject();
    var keysIn = require_keysIn();
    function baseAssignIn(object, source2) {
      return object && copyObject(source2, keysIn(source2), object);
    }
    module2.exports = baseAssignIn;
  }
});

// node_modules/lodash/_cloneBuffer.js
var require_cloneBuffer = __commonJS({
  "node_modules/lodash/_cloneBuffer.js"(exports, module2) {
    var root4 = require_root();
    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var Buffer2 = moduleExports ? root4.Buffer : void 0;
    var allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
    function cloneBuffer(buffer3, isDeep) {
      if (isDeep) {
        return buffer3.slice();
      }
      var length = buffer3.length, result = allocUnsafe ? allocUnsafe(length) : new buffer3.constructor(length);
      buffer3.copy(result);
      return result;
    }
    module2.exports = cloneBuffer;
  }
});

// node_modules/lodash/_copyArray.js
var require_copyArray = __commonJS({
  "node_modules/lodash/_copyArray.js"(exports, module2) {
    function copyArray(source2, array) {
      var index2 = -1, length = source2.length;
      array || (array = Array(length));
      while (++index2 < length) {
        array[index2] = source2[index2];
      }
      return array;
    }
    module2.exports = copyArray;
  }
});

// node_modules/lodash/_arrayFilter.js
var require_arrayFilter = __commonJS({
  "node_modules/lodash/_arrayFilter.js"(exports, module2) {
    function arrayFilter(array, predicate) {
      var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
      while (++index2 < length) {
        var value2 = array[index2];
        if (predicate(value2, index2, array)) {
          result[resIndex++] = value2;
        }
      }
      return result;
    }
    module2.exports = arrayFilter;
  }
});

// node_modules/lodash/stubArray.js
var require_stubArray = __commonJS({
  "node_modules/lodash/stubArray.js"(exports, module2) {
    function stubArray() {
      return [];
    }
    module2.exports = stubArray;
  }
});

// node_modules/lodash/_getSymbols.js
var require_getSymbols = __commonJS({
  "node_modules/lodash/_getSymbols.js"(exports, module2) {
    var arrayFilter = require_arrayFilter();
    var stubArray = require_stubArray();
    var objectProto = Object.prototype;
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
      if (object == null) {
        return [];
      }
      object = Object(object);
      return arrayFilter(nativeGetSymbols(object), function(symbol) {
        return propertyIsEnumerable.call(object, symbol);
      });
    };
    module2.exports = getSymbols;
  }
});

// node_modules/lodash/_copySymbols.js
var require_copySymbols = __commonJS({
  "node_modules/lodash/_copySymbols.js"(exports, module2) {
    var copyObject = require_copyObject();
    var getSymbols = require_getSymbols();
    function copySymbols(source2, object) {
      return copyObject(source2, getSymbols(source2), object);
    }
    module2.exports = copySymbols;
  }
});

// node_modules/lodash/_arrayPush.js
var require_arrayPush = __commonJS({
  "node_modules/lodash/_arrayPush.js"(exports, module2) {
    function arrayPush(array, values) {
      var index2 = -1, length = values.length, offset3 = array.length;
      while (++index2 < length) {
        array[offset3 + index2] = values[index2];
      }
      return array;
    }
    module2.exports = arrayPush;
  }
});

// node_modules/lodash/_getPrototype.js
var require_getPrototype = __commonJS({
  "node_modules/lodash/_getPrototype.js"(exports, module2) {
    var overArg = require_overArg();
    var getPrototype = overArg(Object.getPrototypeOf, Object);
    module2.exports = getPrototype;
  }
});

// node_modules/lodash/_getSymbolsIn.js
var require_getSymbolsIn = __commonJS({
  "node_modules/lodash/_getSymbolsIn.js"(exports, module2) {
    var arrayPush = require_arrayPush();
    var getPrototype = require_getPrototype();
    var getSymbols = require_getSymbols();
    var stubArray = require_stubArray();
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
      var result = [];
      while (object) {
        arrayPush(result, getSymbols(object));
        object = getPrototype(object);
      }
      return result;
    };
    module2.exports = getSymbolsIn;
  }
});

// node_modules/lodash/_copySymbolsIn.js
var require_copySymbolsIn = __commonJS({
  "node_modules/lodash/_copySymbolsIn.js"(exports, module2) {
    var copyObject = require_copyObject();
    var getSymbolsIn = require_getSymbolsIn();
    function copySymbolsIn(source2, object) {
      return copyObject(source2, getSymbolsIn(source2), object);
    }
    module2.exports = copySymbolsIn;
  }
});

// node_modules/lodash/_baseGetAllKeys.js
var require_baseGetAllKeys = __commonJS({
  "node_modules/lodash/_baseGetAllKeys.js"(exports, module2) {
    var arrayPush = require_arrayPush();
    var isArray3 = require_isArray();
    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
      var result = keysFunc(object);
      return isArray3(object) ? result : arrayPush(result, symbolsFunc(object));
    }
    module2.exports = baseGetAllKeys;
  }
});

// node_modules/lodash/_getAllKeys.js
var require_getAllKeys = __commonJS({
  "node_modules/lodash/_getAllKeys.js"(exports, module2) {
    var baseGetAllKeys = require_baseGetAllKeys();
    var getSymbols = require_getSymbols();
    var keys2 = require_keys();
    function getAllKeys(object) {
      return baseGetAllKeys(object, keys2, getSymbols);
    }
    module2.exports = getAllKeys;
  }
});

// node_modules/lodash/_getAllKeysIn.js
var require_getAllKeysIn = __commonJS({
  "node_modules/lodash/_getAllKeysIn.js"(exports, module2) {
    var baseGetAllKeys = require_baseGetAllKeys();
    var getSymbolsIn = require_getSymbolsIn();
    var keysIn = require_keysIn();
    function getAllKeysIn(object) {
      return baseGetAllKeys(object, keysIn, getSymbolsIn);
    }
    module2.exports = getAllKeysIn;
  }
});

// node_modules/lodash/_DataView.js
var require_DataView = __commonJS({
  "node_modules/lodash/_DataView.js"(exports, module2) {
    var getNative = require_getNative();
    var root4 = require_root();
    var DataView = getNative(root4, "DataView");
    module2.exports = DataView;
  }
});

// node_modules/lodash/_Promise.js
var require_Promise = __commonJS({
  "node_modules/lodash/_Promise.js"(exports, module2) {
    var getNative = require_getNative();
    var root4 = require_root();
    var Promise2 = getNative(root4, "Promise");
    module2.exports = Promise2;
  }
});

// node_modules/lodash/_Set.js
var require_Set = __commonJS({
  "node_modules/lodash/_Set.js"(exports, module2) {
    var getNative = require_getNative();
    var root4 = require_root();
    var Set2 = getNative(root4, "Set");
    module2.exports = Set2;
  }
});

// node_modules/lodash/_WeakMap.js
var require_WeakMap = __commonJS({
  "node_modules/lodash/_WeakMap.js"(exports, module2) {
    var getNative = require_getNative();
    var root4 = require_root();
    var WeakMap2 = getNative(root4, "WeakMap");
    module2.exports = WeakMap2;
  }
});

// node_modules/lodash/_getTag.js
var require_getTag = __commonJS({
  "node_modules/lodash/_getTag.js"(exports, module2) {
    var DataView = require_DataView();
    var Map2 = require_Map();
    var Promise2 = require_Promise();
    var Set2 = require_Set();
    var WeakMap2 = require_WeakMap();
    var baseGetTag = require_baseGetTag();
    var toSource = require_toSource();
    var mapTag = "[object Map]";
    var objectTag = "[object Object]";
    var promiseTag = "[object Promise]";
    var setTag = "[object Set]";
    var weakMapTag = "[object WeakMap]";
    var dataViewTag = "[object DataView]";
    var dataViewCtorString = toSource(DataView);
    var mapCtorString = toSource(Map2);
    var promiseCtorString = toSource(Promise2);
    var setCtorString = toSource(Set2);
    var weakMapCtorString = toSource(WeakMap2);
    var getTag = baseGetTag;
    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
      getTag = function(value2) {
        var result = baseGetTag(value2), Ctor = result == objectTag ? value2.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString:
              return dataViewTag;
            case mapCtorString:
              return mapTag;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag;
            case weakMapCtorString:
              return weakMapTag;
          }
        }
        return result;
      };
    }
    module2.exports = getTag;
  }
});

// node_modules/lodash/_initCloneArray.js
var require_initCloneArray = __commonJS({
  "node_modules/lodash/_initCloneArray.js"(exports, module2) {
    var objectProto = Object.prototype;
    var hasOwnProperty4 = objectProto.hasOwnProperty;
    function initCloneArray(array) {
      var length = array.length, result = new array.constructor(length);
      if (length && typeof array[0] == "string" && hasOwnProperty4.call(array, "index")) {
        result.index = array.index;
        result.input = array.input;
      }
      return result;
    }
    module2.exports = initCloneArray;
  }
});

// node_modules/lodash/_Uint8Array.js
var require_Uint8Array = __commonJS({
  "node_modules/lodash/_Uint8Array.js"(exports, module2) {
    var root4 = require_root();
    var Uint8Array2 = root4.Uint8Array;
    module2.exports = Uint8Array2;
  }
});

// node_modules/lodash/_cloneArrayBuffer.js
var require_cloneArrayBuffer = __commonJS({
  "node_modules/lodash/_cloneArrayBuffer.js"(exports, module2) {
    var Uint8Array2 = require_Uint8Array();
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
      return result;
    }
    module2.exports = cloneArrayBuffer;
  }
});

// node_modules/lodash/_cloneDataView.js
var require_cloneDataView = __commonJS({
  "node_modules/lodash/_cloneDataView.js"(exports, module2) {
    var cloneArrayBuffer = require_cloneArrayBuffer();
    function cloneDataView(dataView, isDeep) {
      var buffer3 = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
      return new dataView.constructor(buffer3, dataView.byteOffset, dataView.byteLength);
    }
    module2.exports = cloneDataView;
  }
});

// node_modules/lodash/_cloneRegExp.js
var require_cloneRegExp = __commonJS({
  "node_modules/lodash/_cloneRegExp.js"(exports, module2) {
    var reFlags = /\w*$/;
    function cloneRegExp(regexp) {
      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
      result.lastIndex = regexp.lastIndex;
      return result;
    }
    module2.exports = cloneRegExp;
  }
});

// node_modules/lodash/_cloneSymbol.js
var require_cloneSymbol = __commonJS({
  "node_modules/lodash/_cloneSymbol.js"(exports, module2) {
    var Symbol2 = require_Symbol();
    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
    function cloneSymbol(symbol) {
      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
    }
    module2.exports = cloneSymbol;
  }
});

// node_modules/lodash/_cloneTypedArray.js
var require_cloneTypedArray = __commonJS({
  "node_modules/lodash/_cloneTypedArray.js"(exports, module2) {
    var cloneArrayBuffer = require_cloneArrayBuffer();
    function cloneTypedArray(typedArray, isDeep) {
      var buffer3 = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
      return new typedArray.constructor(buffer3, typedArray.byteOffset, typedArray.length);
    }
    module2.exports = cloneTypedArray;
  }
});

// node_modules/lodash/_initCloneByTag.js
var require_initCloneByTag = __commonJS({
  "node_modules/lodash/_initCloneByTag.js"(exports, module2) {
    var cloneArrayBuffer = require_cloneArrayBuffer();
    var cloneDataView = require_cloneDataView();
    var cloneRegExp = require_cloneRegExp();
    var cloneSymbol = require_cloneSymbol();
    var cloneTypedArray = require_cloneTypedArray();
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var regexpTag = "[object RegExp]";
    var setTag = "[object Set]";
    var stringTag = "[object String]";
    var symbolTag = "[object Symbol]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    function initCloneByTag(object, tag, isDeep) {
      var Ctor = object.constructor;
      switch (tag) {
        case arrayBufferTag:
          return cloneArrayBuffer(object);
        case boolTag:
        case dateTag:
          return new Ctor(+object);
        case dataViewTag:
          return cloneDataView(object, isDeep);
        case float32Tag:
        case float64Tag:
        case int8Tag:
        case int16Tag:
        case int32Tag:
        case uint8Tag:
        case uint8ClampedTag:
        case uint16Tag:
        case uint32Tag:
          return cloneTypedArray(object, isDeep);
        case mapTag:
          return new Ctor();
        case numberTag:
        case stringTag:
          return new Ctor(object);
        case regexpTag:
          return cloneRegExp(object);
        case setTag:
          return new Ctor();
        case symbolTag:
          return cloneSymbol(object);
      }
    }
    module2.exports = initCloneByTag;
  }
});

// node_modules/lodash/_baseCreate.js
var require_baseCreate = __commonJS({
  "node_modules/lodash/_baseCreate.js"(exports, module2) {
    var isObject = require_isObject();
    var objectCreate = Object.create;
    var baseCreate = function() {
      function object() {
      }
      return function(proto) {
        if (!isObject(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object.prototype = proto;
        var result = new object();
        object.prototype = void 0;
        return result;
      };
    }();
    module2.exports = baseCreate;
  }
});

// node_modules/lodash/_initCloneObject.js
var require_initCloneObject = __commonJS({
  "node_modules/lodash/_initCloneObject.js"(exports, module2) {
    var baseCreate = require_baseCreate();
    var getPrototype = require_getPrototype();
    var isPrototype = require_isPrototype();
    function initCloneObject(object) {
      return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
    }
    module2.exports = initCloneObject;
  }
});

// node_modules/lodash/_baseIsMap.js
var require_baseIsMap = __commonJS({
  "node_modules/lodash/_baseIsMap.js"(exports, module2) {
    var getTag = require_getTag();
    var isObjectLike = require_isObjectLike();
    var mapTag = "[object Map]";
    function baseIsMap(value2) {
      return isObjectLike(value2) && getTag(value2) == mapTag;
    }
    module2.exports = baseIsMap;
  }
});

// node_modules/lodash/isMap.js
var require_isMap = __commonJS({
  "node_modules/lodash/isMap.js"(exports, module2) {
    var baseIsMap = require_baseIsMap();
    var baseUnary = require_baseUnary();
    var nodeUtil = require_nodeUtil();
    var nodeIsMap = nodeUtil && nodeUtil.isMap;
    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
    module2.exports = isMap;
  }
});

// node_modules/lodash/_baseIsSet.js
var require_baseIsSet = __commonJS({
  "node_modules/lodash/_baseIsSet.js"(exports, module2) {
    var getTag = require_getTag();
    var isObjectLike = require_isObjectLike();
    var setTag = "[object Set]";
    function baseIsSet(value2) {
      return isObjectLike(value2) && getTag(value2) == setTag;
    }
    module2.exports = baseIsSet;
  }
});

// node_modules/lodash/isSet.js
var require_isSet = __commonJS({
  "node_modules/lodash/isSet.js"(exports, module2) {
    var baseIsSet = require_baseIsSet();
    var baseUnary = require_baseUnary();
    var nodeUtil = require_nodeUtil();
    var nodeIsSet = nodeUtil && nodeUtil.isSet;
    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
    module2.exports = isSet;
  }
});

// node_modules/lodash/_baseClone.js
var require_baseClone = __commonJS({
  "node_modules/lodash/_baseClone.js"(exports, module2) {
    var Stack = require_Stack();
    var arrayEach = require_arrayEach();
    var assignValue = require_assignValue();
    var baseAssign = require_baseAssign();
    var baseAssignIn = require_baseAssignIn();
    var cloneBuffer = require_cloneBuffer();
    var copyArray = require_copyArray();
    var copySymbols = require_copySymbols();
    var copySymbolsIn = require_copySymbolsIn();
    var getAllKeys = require_getAllKeys();
    var getAllKeysIn = require_getAllKeysIn();
    var getTag = require_getTag();
    var initCloneArray = require_initCloneArray();
    var initCloneByTag = require_initCloneByTag();
    var initCloneObject = require_initCloneObject();
    var isArray3 = require_isArray();
    var isBuffer2 = require_isBuffer();
    var isMap = require_isMap();
    var isObject = require_isObject();
    var isSet = require_isSet();
    var keys2 = require_keys();
    var keysIn = require_keysIn();
    var CLONE_DEEP_FLAG = 1;
    var CLONE_FLAT_FLAG = 2;
    var CLONE_SYMBOLS_FLAG = 4;
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var errorTag = "[object Error]";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var objectTag = "[object Object]";
    var regexpTag = "[object RegExp]";
    var setTag = "[object Set]";
    var stringTag = "[object String]";
    var symbolTag = "[object Symbol]";
    var weakMapTag = "[object WeakMap]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    var cloneableTags = {};
    cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
    cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
    function baseClone(value2, bitmask, customizer, key2, object, stack2) {
      var result, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
      if (customizer) {
        result = object ? customizer(value2, key2, object, stack2) : customizer(value2);
      }
      if (result !== void 0) {
        return result;
      }
      if (!isObject(value2)) {
        return value2;
      }
      var isArr = isArray3(value2);
      if (isArr) {
        result = initCloneArray(value2);
        if (!isDeep) {
          return copyArray(value2, result);
        }
      } else {
        var tag = getTag(value2), isFunc = tag == funcTag || tag == genTag;
        if (isBuffer2(value2)) {
          return cloneBuffer(value2, isDeep);
        }
        if (tag == objectTag || tag == argsTag || isFunc && !object) {
          result = isFlat || isFunc ? {} : initCloneObject(value2);
          if (!isDeep) {
            return isFlat ? copySymbolsIn(value2, baseAssignIn(result, value2)) : copySymbols(value2, baseAssign(result, value2));
          }
        } else {
          if (!cloneableTags[tag]) {
            return object ? value2 : {};
          }
          result = initCloneByTag(value2, tag, isDeep);
        }
      }
      stack2 || (stack2 = new Stack());
      var stacked = stack2.get(value2);
      if (stacked) {
        return stacked;
      }
      stack2.set(value2, result);
      if (isSet(value2)) {
        value2.forEach(function(subValue) {
          result.add(baseClone(subValue, bitmask, customizer, subValue, value2, stack2));
        });
      } else if (isMap(value2)) {
        value2.forEach(function(subValue, key3) {
          result.set(key3, baseClone(subValue, bitmask, customizer, key3, value2, stack2));
        });
      }
      var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys2;
      var props = isArr ? void 0 : keysFunc(value2);
      arrayEach(props || value2, function(subValue, key3) {
        if (props) {
          key3 = subValue;
          subValue = value2[key3];
        }
        assignValue(result, key3, baseClone(subValue, bitmask, customizer, key3, value2, stack2));
      });
      return result;
    }
    module2.exports = baseClone;
  }
});

// node_modules/lodash/cloneDeep.js
var require_cloneDeep2 = __commonJS({
  "node_modules/lodash/cloneDeep.js"(exports, module2) {
    var baseClone = require_baseClone();
    var CLONE_DEEP_FLAG = 1;
    var CLONE_SYMBOLS_FLAG = 4;
    function cloneDeep2(value2) {
      return baseClone(value2, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
    }
    module2.exports = cloneDeep2;
  }
});

// node_modules/@babel/traverse/lib/path/lib/virtual-types.js
var require_virtual_types = __commonJS({
  "node_modules/@babel/traverse/lib/path/lib/virtual-types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.Var = exports.User = exports.Statement = exports.SpreadProperty = exports.Scope = exports.RestProperty = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = exports.Referenced = exports.Pure = exports.NumericLiteralTypeAnnotation = exports.Generated = exports.ForAwaitStatement = exports.Flow = exports.Expression = exports.ExistentialTypeParam = exports.BlockScoped = exports.BindingIdentifier = void 0;
    var ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
    exports.ReferencedIdentifier = ReferencedIdentifier;
    var ReferencedMemberExpression = ["MemberExpression"];
    exports.ReferencedMemberExpression = ReferencedMemberExpression;
    var BindingIdentifier = ["Identifier"];
    exports.BindingIdentifier = BindingIdentifier;
    var Statement = ["Statement"];
    exports.Statement = Statement;
    var Expression = ["Expression"];
    exports.Expression = Expression;
    var Scope6 = ["Scopable", "Pattern"];
    exports.Scope = Scope6;
    var Referenced = null;
    exports.Referenced = Referenced;
    var BlockScoped = null;
    exports.BlockScoped = BlockScoped;
    var Var = ["VariableDeclaration"];
    exports.Var = Var;
    var User = null;
    exports.User = User;
    var Generated = null;
    exports.Generated = Generated;
    var Pure = null;
    exports.Pure = Pure;
    var Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
    exports.Flow = Flow;
    var RestProperty = ["RestElement"];
    exports.RestProperty = RestProperty;
    var SpreadProperty = ["RestElement"];
    exports.SpreadProperty = SpreadProperty;
    var ExistentialTypeParam = ["ExistsTypeAnnotation"];
    exports.ExistentialTypeParam = ExistentialTypeParam;
    var NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"];
    exports.NumericLiteralTypeAnnotation = NumericLiteralTypeAnnotation;
    var ForAwaitStatement = ["ForOfStatement"];
    exports.ForAwaitStatement = ForAwaitStatement;
  }
});

// node_modules/@babel/traverse/lib/visitors.js
var require_visitors = __commonJS({
  "node_modules/@babel/traverse/lib/visitors.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.explode = explode;
    exports.merge = merge2;
    exports.verify = verify;
    var virtualTypes = require_virtual_types();
    var _t = require_lib3();
    var {
      DEPRECATED_KEYS,
      DEPRECATED_ALIASES,
      FLIPPED_ALIAS_KEYS,
      TYPES,
      __internal__deprecationWarning: deprecationWarning
    } = _t;
    function isVirtualType(type) {
      return type in virtualTypes;
    }
    function explode(visitor) {
      if (visitor._exploded)
        return visitor;
      visitor._exploded = true;
      for (const nodeType of Object.keys(visitor)) {
        if (shouldIgnoreKey(nodeType))
          continue;
        const parts = nodeType.split("|");
        if (parts.length === 1)
          continue;
        const fns = visitor[nodeType];
        delete visitor[nodeType];
        for (const part of parts) {
          visitor[part] = fns;
        }
      }
      verify(visitor);
      delete visitor.__esModule;
      ensureEntranceObjects(visitor);
      ensureCallbackArrays(visitor);
      for (const nodeType of Object.keys(visitor)) {
        if (shouldIgnoreKey(nodeType))
          continue;
        if (!isVirtualType(nodeType))
          continue;
        const fns = visitor[nodeType];
        for (const type of Object.keys(fns)) {
          fns[type] = wrapCheck(nodeType, fns[type]);
        }
        delete visitor[nodeType];
        const types3 = virtualTypes[nodeType];
        if (types3 !== null) {
          for (const type of types3) {
            if (visitor[type]) {
              mergePair(visitor[type], fns);
            } else {
              visitor[type] = fns;
            }
          }
        } else {
          mergePair(visitor, fns);
        }
      }
      for (const nodeType of Object.keys(visitor)) {
        if (shouldIgnoreKey(nodeType))
          continue;
        let aliases = FLIPPED_ALIAS_KEYS[nodeType];
        if (nodeType in DEPRECATED_KEYS) {
          const deprecatedKey = DEPRECATED_KEYS[nodeType];
          deprecationWarning(nodeType, deprecatedKey, "Visitor ");
          aliases = [deprecatedKey];
        } else if (nodeType in DEPRECATED_ALIASES) {
          const deprecatedAlias = DEPRECATED_ALIASES[nodeType];
          deprecationWarning(nodeType, deprecatedAlias, "Visitor ");
          aliases = FLIPPED_ALIAS_KEYS[deprecatedAlias];
        }
        if (!aliases)
          continue;
        const fns = visitor[nodeType];
        delete visitor[nodeType];
        for (const alias of aliases) {
          const existing = visitor[alias];
          if (existing) {
            mergePair(existing, fns);
          } else {
            visitor[alias] = Object.assign({}, fns);
          }
        }
      }
      for (const nodeType of Object.keys(visitor)) {
        if (shouldIgnoreKey(nodeType))
          continue;
        ensureCallbackArrays(visitor[nodeType]);
      }
      return visitor;
    }
    function verify(visitor) {
      if (visitor._verified)
        return;
      if (typeof visitor === "function") {
        throw new Error("You passed `traverse()` a function when it expected a visitor object, are you sure you didn't mean `{ enter: Function }`?");
      }
      for (const nodeType of Object.keys(visitor)) {
        if (nodeType === "enter" || nodeType === "exit") {
          validateVisitorMethods(nodeType, visitor[nodeType]);
        }
        if (shouldIgnoreKey(nodeType))
          continue;
        if (TYPES.indexOf(nodeType) < 0) {
          throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type`);
        }
        const visitors = visitor[nodeType];
        if (typeof visitors === "object") {
          for (const visitorKey of Object.keys(visitors)) {
            if (visitorKey === "enter" || visitorKey === "exit") {
              validateVisitorMethods(`${nodeType}.${visitorKey}`, visitors[visitorKey]);
            } else {
              throw new Error(`You passed \`traverse()\` a visitor object with the property ${nodeType} that has the invalid property ${visitorKey}`);
            }
          }
        }
      }
      visitor._verified = true;
    }
    function validateVisitorMethods(path, val) {
      const fns = [].concat(val);
      for (const fn of fns) {
        if (typeof fn !== "function") {
          throw new TypeError(`Non-function found defined in ${path} with type ${typeof fn}`);
        }
      }
    }
    function merge2(visitors, states = [], wrapper) {
      const rootVisitor = {};
      for (let i = 0; i < visitors.length; i++) {
        const visitor = visitors[i];
        const state = states[i];
        explode(visitor);
        for (const type of Object.keys(visitor)) {
          let visitorType = visitor[type];
          if (state || wrapper) {
            visitorType = wrapWithStateOrWrapper(visitorType, state, wrapper);
          }
          const nodeVisitor = rootVisitor[type] || (rootVisitor[type] = {});
          mergePair(nodeVisitor, visitorType);
        }
      }
      return rootVisitor;
    }
    function wrapWithStateOrWrapper(oldVisitor, state, wrapper) {
      const newVisitor = {};
      for (const key2 of Object.keys(oldVisitor)) {
        let fns = oldVisitor[key2];
        if (!Array.isArray(fns))
          continue;
        fns = fns.map(function(fn) {
          let newFn = fn;
          if (state) {
            newFn = function(path) {
              return fn.call(state, path, state);
            };
          }
          if (wrapper) {
            newFn = wrapper(state.key, key2, newFn);
          }
          if (newFn !== fn) {
            newFn.toString = () => fn.toString();
          }
          return newFn;
        });
        newVisitor[key2] = fns;
      }
      return newVisitor;
    }
    function ensureEntranceObjects(obj) {
      for (const key2 of Object.keys(obj)) {
        if (shouldIgnoreKey(key2))
          continue;
        const fns = obj[key2];
        if (typeof fns === "function") {
          obj[key2] = {
            enter: fns
          };
        }
      }
    }
    function ensureCallbackArrays(obj) {
      if (obj.enter && !Array.isArray(obj.enter))
        obj.enter = [obj.enter];
      if (obj.exit && !Array.isArray(obj.exit))
        obj.exit = [obj.exit];
    }
    function wrapCheck(nodeType, fn) {
      const newFn = function(path) {
        if (path[`is${nodeType}`]()) {
          return fn.apply(this, arguments);
        }
      };
      newFn.toString = () => fn.toString();
      return newFn;
    }
    function shouldIgnoreKey(key2) {
      if (key2[0] === "_")
        return true;
      if (key2 === "enter" || key2 === "exit" || key2 === "shouldSkip")
        return true;
      if (key2 === "denylist" || key2 === "noScope" || key2 === "skipKeys" || key2 === "blacklist") {
        return true;
      }
      return false;
    }
    function mergePair(dest, src) {
      for (const key2 of Object.keys(src)) {
        dest[key2] = [].concat(dest[key2] || [], src[key2]);
      }
    }
  }
});

// node_modules/@babel/traverse/lib/cache.js
var require_cache = __commonJS({
  "node_modules/@babel/traverse/lib/cache.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.clear = clear;
    exports.clearPath = clearPath;
    exports.clearScope = clearScope;
    exports.scope = exports.path = void 0;
    var path = /* @__PURE__ */ new WeakMap();
    exports.path = path;
    var scope = /* @__PURE__ */ new WeakMap();
    exports.scope = scope;
    function clear() {
      clearPath();
      clearScope();
    }
    function clearPath() {
      exports.path = path = /* @__PURE__ */ new WeakMap();
    }
    function clearScope() {
      exports.scope = scope = /* @__PURE__ */ new WeakMap();
    }
  }
});

// node_modules/ms/index.js
var require_ms = __commonJS({
  "node_modules/ms/index.js"(exports, module2) {
    var s = 1e3;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var w = d * 7;
    var y = d * 365.25;
    module2.exports = function(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse9(val);
      } else if (type === "number" && isFinite(val)) {
        return options.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse9(str) {
      str = String(str);
      if (str.length > 100) {
        return;
      }
      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
        str
      );
      if (!match) {
        return;
      }
      var n = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n * y;
        case "weeks":
        case "week":
        case "w":
          return n * w;
        case "days":
        case "day":
        case "d":
          return n * d;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n * h;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n * m;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n;
        default:
          return void 0;
      }
    }
    function fmtShort(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d) {
        return Math.round(ms / d) + "d";
      }
      if (msAbs >= h) {
        return Math.round(ms / h) + "h";
      }
      if (msAbs >= m) {
        return Math.round(ms / m) + "m";
      }
      if (msAbs >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    function fmtLong(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d) {
        return plural(ms, msAbs, d, "day");
      }
      if (msAbs >= h) {
        return plural(ms, msAbs, h, "hour");
      }
      if (msAbs >= m) {
        return plural(ms, msAbs, m, "minute");
      }
      if (msAbs >= s) {
        return plural(ms, msAbs, s, "second");
      }
      return ms + " ms";
    }
    function plural(ms, msAbs, n, name2) {
      var isPlural = msAbs >= n * 1.5;
      return Math.round(ms / n) + " " + name2 + (isPlural ? "s" : "");
    }
  }
});

// node_modules/debug/src/common.js
var require_common = __commonJS({
  "node_modules/debug/src/common.js"(exports, module2) {
    function setup(env) {
      createDebug.debug = createDebug;
      createDebug.default = createDebug;
      createDebug.coerce = coerce;
      createDebug.disable = disable2;
      createDebug.enable = enable;
      createDebug.enabled = enabled;
      createDebug.humanize = require_ms();
      createDebug.destroy = destroy;
      Object.keys(env).forEach((key2) => {
        createDebug[key2] = env[key2];
      });
      createDebug.names = [];
      createDebug.skips = [];
      createDebug.formatters = {};
      function selectColor(namespace) {
        let hash = 0;
        for (let i = 0; i < namespace.length; i++) {
          hash = (hash << 5) - hash + namespace.charCodeAt(i);
          hash |= 0;
        }
        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
      }
      createDebug.selectColor = selectColor;
      function createDebug(namespace) {
        let prevTime;
        let enableOverride = null;
        let namespacesCache;
        let enabledCache;
        function debug(...args) {
          if (!debug.enabled) {
            return;
          }
          const self2 = debug;
          const curr = Number(/* @__PURE__ */ new Date());
          const ms = curr - (prevTime || curr);
          self2.diff = ms;
          self2.prev = prevTime;
          self2.curr = curr;
          prevTime = curr;
          args[0] = createDebug.coerce(args[0]);
          if (typeof args[0] !== "string") {
            args.unshift("%O");
          }
          let index2 = 0;
          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
            if (match === "%%") {
              return "%";
            }
            index2++;
            const formatter = createDebug.formatters[format];
            if (typeof formatter === "function") {
              const val = args[index2];
              match = formatter.call(self2, val);
              args.splice(index2, 1);
              index2--;
            }
            return match;
          });
          createDebug.formatArgs.call(self2, args);
          const logFn = self2.log || createDebug.log;
          logFn.apply(self2, args);
        }
        debug.namespace = namespace;
        debug.useColors = createDebug.useColors();
        debug.color = createDebug.selectColor(namespace);
        debug.extend = extend4;
        debug.destroy = createDebug.destroy;
        Object.defineProperty(debug, "enabled", {
          enumerable: true,
          configurable: false,
          get: () => {
            if (enableOverride !== null) {
              return enableOverride;
            }
            if (namespacesCache !== createDebug.namespaces) {
              namespacesCache = createDebug.namespaces;
              enabledCache = createDebug.enabled(namespace);
            }
            return enabledCache;
          },
          set: (v) => {
            enableOverride = v;
          }
        });
        if (typeof createDebug.init === "function") {
          createDebug.init(debug);
        }
        return debug;
      }
      function extend4(namespace, delimiter) {
        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
        newDebug.log = this.log;
        return newDebug;
      }
      function enable(namespaces) {
        createDebug.save(namespaces);
        createDebug.namespaces = namespaces;
        createDebug.names = [];
        createDebug.skips = [];
        let i;
        const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
        const len = split.length;
        for (i = 0; i < len; i++) {
          if (!split[i]) {
            continue;
          }
          namespaces = split[i].replace(/\*/g, ".*?");
          if (namespaces[0] === "-") {
            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
          } else {
            createDebug.names.push(new RegExp("^" + namespaces + "$"));
          }
        }
      }
      function disable2() {
        const namespaces = [
          ...createDebug.names.map(toNamespace),
          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
        ].join(",");
        createDebug.enable("");
        return namespaces;
      }
      function enabled(name2) {
        if (name2[name2.length - 1] === "*") {
          return true;
        }
        let i;
        let len;
        for (i = 0, len = createDebug.skips.length; i < len; i++) {
          if (createDebug.skips[i].test(name2)) {
            return false;
          }
        }
        for (i = 0, len = createDebug.names.length; i < len; i++) {
          if (createDebug.names[i].test(name2)) {
            return true;
          }
        }
        return false;
      }
      function toNamespace(regexp) {
        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
      }
      function coerce(val) {
        if (val instanceof Error) {
          return val.stack || val.message;
        }
        return val;
      }
      function destroy() {
        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
      }
      createDebug.enable(createDebug.load());
      return createDebug;
    }
    module2.exports = setup;
  }
});

// node_modules/debug/src/browser.js
var require_browser = __commonJS({
  "node_modules/debug/src/browser.js"(exports, module2) {
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    exports.storage = localstorage();
    exports.destroy = (() => {
      let warned = false;
      return () => {
        if (!warned) {
          warned = true;
          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
        }
      };
    })();
    exports.colors = [
      "#0000CC",
      "#0000FF",
      "#0033CC",
      "#0033FF",
      "#0066CC",
      "#0066FF",
      "#0099CC",
      "#0099FF",
      "#00CC00",
      "#00CC33",
      "#00CC66",
      "#00CC99",
      "#00CCCC",
      "#00CCFF",
      "#3300CC",
      "#3300FF",
      "#3333CC",
      "#3333FF",
      "#3366CC",
      "#3366FF",
      "#3399CC",
      "#3399FF",
      "#33CC00",
      "#33CC33",
      "#33CC66",
      "#33CC99",
      "#33CCCC",
      "#33CCFF",
      "#6600CC",
      "#6600FF",
      "#6633CC",
      "#6633FF",
      "#66CC00",
      "#66CC33",
      "#9900CC",
      "#9900FF",
      "#9933CC",
      "#9933FF",
      "#99CC00",
      "#99CC33",
      "#CC0000",
      "#CC0033",
      "#CC0066",
      "#CC0099",
      "#CC00CC",
      "#CC00FF",
      "#CC3300",
      "#CC3333",
      "#CC3366",
      "#CC3399",
      "#CC33CC",
      "#CC33FF",
      "#CC6600",
      "#CC6633",
      "#CC9900",
      "#CC9933",
      "#CCCC00",
      "#CCCC33",
      "#FF0000",
      "#FF0033",
      "#FF0066",
      "#FF0099",
      "#FF00CC",
      "#FF00FF",
      "#FF3300",
      "#FF3333",
      "#FF3366",
      "#FF3399",
      "#FF33CC",
      "#FF33FF",
      "#FF6600",
      "#FF6633",
      "#FF9900",
      "#FF9933",
      "#FFCC00",
      "#FFCC33"
    ];
    function useColors() {
      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
        return true;
      }
      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
        return false;
      }
      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
    }
    function formatArgs(args) {
      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
      if (!this.useColors) {
        return;
      }
      const c2 = "color: " + this.color;
      args.splice(1, 0, c2, "color: inherit");
      let index2 = 0;
      let lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, (match) => {
        if (match === "%%") {
          return;
        }
        index2++;
        if (match === "%c") {
          lastC = index2;
        }
      });
      args.splice(lastC, 0, c2);
    }
    exports.log = console.debug || console.log || (() => {
    });
    function save(namespaces) {
      try {
        if (namespaces) {
          exports.storage.setItem("debug", namespaces);
        } else {
          exports.storage.removeItem("debug");
        }
      } catch (error) {
      }
    }
    function load() {
      let r;
      try {
        r = exports.storage.getItem("debug");
      } catch (error) {
      }
      if (!r && typeof process !== "undefined" && "env" in process) {
        r = process.env.DEBUG;
      }
      return r;
    }
    function localstorage() {
      try {
        return localStorage;
      } catch (error) {
      }
    }
    module2.exports = require_common()(exports);
    var { formatters } = module2.exports;
    formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (error) {
        return "[UnexpectedJSONParseError]: " + error.message;
      }
    };
  }
});

// node_modules/has-flag/index.js
var require_has_flag = __commonJS({
  "node_modules/has-flag/index.js"(exports, module2) {
    "use strict";
    module2.exports = (flag, argv = process.argv) => {
      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
      const position3 = argv.indexOf(prefix + flag);
      const terminatorPosition = argv.indexOf("--");
      return position3 !== -1 && (terminatorPosition === -1 || position3 < terminatorPosition);
    };
  }
});

// node_modules/supports-color/index.js
var require_supports_color = __commonJS({
  "node_modules/supports-color/index.js"(exports, module2) {
    "use strict";
    var os = require("os");
    var tty = require("tty");
    var hasFlag = require_has_flag();
    var { env } = process;
    var forceColor;
    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
      forceColor = 0;
    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
      forceColor = 1;
    }
    if ("FORCE_COLOR" in env) {
      if (env.FORCE_COLOR === "true") {
        forceColor = 1;
      } else if (env.FORCE_COLOR === "false") {
        forceColor = 0;
      } else {
        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
      }
    }
    function translateLevel(level) {
      if (level === 0) {
        return false;
      }
      return {
        level,
        hasBasic: true,
        has256: level >= 2,
        has16m: level >= 3
      };
    }
    function supportsColor(haveStream, streamIsTTY) {
      if (forceColor === 0) {
        return 0;
      }
      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
        return 3;
      }
      if (hasFlag("color=256")) {
        return 2;
      }
      if (haveStream && !streamIsTTY && forceColor === void 0) {
        return 0;
      }
      const min = forceColor || 0;
      if (env.TERM === "dumb") {
        return min;
      }
      if (process.platform === "win32") {
        const osRelease = os.release().split(".");
        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
          return Number(osRelease[2]) >= 14931 ? 3 : 2;
        }
        return 1;
      }
      if ("CI" in env) {
        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign2) => sign2 in env) || env.CI_NAME === "codeship") {
          return 1;
        }
        return min;
      }
      if ("TEAMCITY_VERSION" in env) {
        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
      }
      if (env.COLORTERM === "truecolor") {
        return 3;
      }
      if ("TERM_PROGRAM" in env) {
        const version3 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
        switch (env.TERM_PROGRAM) {
          case "iTerm.app":
            return version3 >= 3 ? 3 : 2;
          case "Apple_Terminal":
            return 2;
        }
      }
      if (/-256(color)?$/i.test(env.TERM)) {
        return 2;
      }
      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
        return 1;
      }
      if ("COLORTERM" in env) {
        return 1;
      }
      return min;
    }
    function getSupportLevel(stream) {
      const level = supportsColor(stream, stream && stream.isTTY);
      return translateLevel(level);
    }
    module2.exports = {
      supportsColor: getSupportLevel,
      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
    };
  }
});

// node_modules/debug/src/node.js
var require_node2 = __commonJS({
  "node_modules/debug/src/node.js"(exports, module2) {
    var tty = require("tty");
    var util2 = require("util");
    exports.init = init;
    exports.log = log;
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    exports.destroy = util2.deprecate(
      () => {
      },
      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
    );
    exports.colors = [6, 2, 3, 4, 5, 1];
    try {
      const supportsColor = require_supports_color();
      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
        exports.colors = [
          20,
          21,
          26,
          27,
          32,
          33,
          38,
          39,
          40,
          41,
          42,
          43,
          44,
          45,
          56,
          57,
          62,
          63,
          68,
          69,
          74,
          75,
          76,
          77,
          78,
          79,
          80,
          81,
          92,
          93,
          98,
          99,
          112,
          113,
          128,
          129,
          134,
          135,
          148,
          149,
          160,
          161,
          162,
          163,
          164,
          165,
          166,
          167,
          168,
          169,
          170,
          171,
          172,
          173,
          178,
          179,
          184,
          185,
          196,
          197,
          198,
          199,
          200,
          201,
          202,
          203,
          204,
          205,
          206,
          207,
          208,
          209,
          214,
          215,
          220,
          221
        ];
      }
    } catch (error) {
    }
    exports.inspectOpts = Object.keys(process.env).filter((key2) => {
      return /^debug_/i.test(key2);
    }).reduce((obj, key2) => {
      const prop = key2.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
        return k.toUpperCase();
      });
      let val = process.env[key2];
      if (/^(yes|on|true|enabled)$/i.test(val)) {
        val = true;
      } else if (/^(no|off|false|disabled)$/i.test(val)) {
        val = false;
      } else if (val === "null") {
        val = null;
      } else {
        val = Number(val);
      }
      obj[prop] = val;
      return obj;
    }, {});
    function useColors() {
      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
    }
    function formatArgs(args) {
      const { namespace: name2, useColors: useColors2 } = this;
      if (useColors2) {
        const c2 = this.color;
        const colorCode = "\x1B[3" + (c2 < 8 ? c2 : "8;5;" + c2);
        const prefix = `  ${colorCode};1m${name2} \x1B[0m`;
        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
      } else {
        args[0] = getDate() + name2 + " " + args[0];
      }
    }
    function getDate() {
      if (exports.inspectOpts.hideDate) {
        return "";
      }
      return (/* @__PURE__ */ new Date()).toISOString() + " ";
    }
    function log(...args) {
      return process.stderr.write(util2.format(...args) + "\n");
    }
    function save(namespaces) {
      if (namespaces) {
        process.env.DEBUG = namespaces;
      } else {
        delete process.env.DEBUG;
      }
    }
    function load() {
      return process.env.DEBUG;
    }
    function init(debug) {
      debug.inspectOpts = {};
      const keys2 = Object.keys(exports.inspectOpts);
      for (let i = 0; i < keys2.length; i++) {
        debug.inspectOpts[keys2[i]] = exports.inspectOpts[keys2[i]];
      }
    }
    module2.exports = require_common()(exports);
    var { formatters } = module2.exports;
    formatters.o = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util2.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
    };
    formatters.O = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util2.inspect(v, this.inspectOpts);
    };
  }
});

// node_modules/debug/src/index.js
var require_src = __commonJS({
  "node_modules/debug/src/index.js"(exports, module2) {
    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
      module2.exports = require_browser();
    } else {
      module2.exports = require_node2();
    }
  }
});

// node_modules/@babel/helper-split-export-declaration/lib/index.js
var require_lib5 = __commonJS({
  "node_modules/@babel/helper-split-export-declaration/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = splitExportDeclaration;
    var _t = require_lib3();
    var {
      cloneNode,
      exportNamedDeclaration,
      exportSpecifier,
      identifier,
      variableDeclaration,
      variableDeclarator
    } = _t;
    function splitExportDeclaration(exportDeclaration) {
      if (!exportDeclaration.isExportDeclaration() || exportDeclaration.isExportAllDeclaration()) {
        throw new Error("Only default and named export declarations can be split.");
      }
      if (exportDeclaration.isExportDefaultDeclaration()) {
        const declaration2 = exportDeclaration.get("declaration");
        const standaloneDeclaration = declaration2.isFunctionDeclaration() || declaration2.isClassDeclaration();
        const scope = declaration2.isScope() ? declaration2.scope.parent : declaration2.scope;
        let id = declaration2.node.id;
        let needBindingRegistration = false;
        if (!id) {
          needBindingRegistration = true;
          id = scope.generateUidIdentifier("default");
          if (standaloneDeclaration || declaration2.isFunctionExpression() || declaration2.isClassExpression()) {
            declaration2.node.id = cloneNode(id);
          }
        }
        const updatedDeclaration = standaloneDeclaration ? declaration2.node : variableDeclaration("var", [variableDeclarator(cloneNode(id), declaration2.node)]);
        const updatedExportDeclaration = exportNamedDeclaration(null, [exportSpecifier(cloneNode(id), identifier("default"))]);
        exportDeclaration.insertAfter(updatedExportDeclaration);
        exportDeclaration.replaceWith(updatedDeclaration);
        if (needBindingRegistration) {
          scope.registerDeclaration(exportDeclaration);
        }
        return exportDeclaration;
      } else if (exportDeclaration.get("specifiers").length > 0) {
        throw new Error("It doesn't make sense to split exported specifiers.");
      }
      const declaration = exportDeclaration.get("declaration");
      const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
      const specifiers = Object.keys(bindingIdentifiers).map((name2) => {
        return exportSpecifier(identifier(name2), identifier(name2));
      });
      const aliasDeclar = exportNamedDeclaration(null, specifiers);
      exportDeclaration.insertAfter(aliasDeclar);
      exportDeclaration.replaceWith(declaration.node);
      return exportDeclaration;
    }
  }
});

// node_modules/@babel/helper-environment-visitor/lib/index.js
var require_lib6 = __commonJS({
  "node_modules/@babel/helper-environment-visitor/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    exports.requeueComputedKeyAndDecorators = requeueComputedKeyAndDecorators;
    exports.skipAllButComputedKey = skipAllButComputedKey;
    function skipAllButComputedKey(path) {
      path.skip();
      if (path.node.computed) {
        path.context.maybeQueue(path.get("key"));
      }
    }
    function requeueComputedKeyAndDecorators(path) {
      const {
        context,
        node: node2
      } = path;
      if (node2.computed) {
        context.maybeQueue(path.get("key"));
      }
      if (node2.decorators) {
        for (const decorator of path.get("decorators")) {
          context.maybeQueue(decorator);
        }
      }
    }
    var visitor = {
      FunctionParent(path) {
        if (path.isArrowFunctionExpression()) {
          return;
        } else {
          path.skip();
          if (path.isMethod()) {
            requeueComputedKeyAndDecorators(path);
          }
        }
      },
      Property(path) {
        if (path.isObjectProperty()) {
          return;
        }
        path.skip();
        requeueComputedKeyAndDecorators(path);
      }
    };
    var _default = visitor;
    exports.default = _default;
  }
});

// node_modules/@babel/traverse/lib/scope/lib/renamer.js
var require_renamer = __commonJS({
  "node_modules/@babel/traverse/lib/scope/lib/renamer.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperSplitExportDeclaration = require_lib5();
    var t3 = require_lib3();
    var _helperEnvironmentVisitor = require_lib6();
    var _traverseNode = require_traverse_node();
    var _visitors = require_visitors();
    var renameVisitor = {
      ReferencedIdentifier({
        node: node2
      }, state) {
        if (node2.name === state.oldName) {
          node2.name = state.newName;
        }
      },
      Scope(path, state) {
        if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
          path.skip();
          if (path.isMethod()) {
            (0, _helperEnvironmentVisitor.requeueComputedKeyAndDecorators)(path);
          }
        }
      },
      "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
        if (path.isVariableDeclaration())
          return;
        const ids = path.getOuterBindingIdentifiers();
        for (const name2 in ids) {
          if (name2 === state.oldName)
            ids[name2].name = state.newName;
        }
      }
    };
    var Renamer = class {
      constructor(binding, oldName, newName) {
        this.newName = newName;
        this.oldName = oldName;
        this.binding = binding;
      }
      maybeConvertFromExportDeclaration(parentDeclar) {
        const maybeExportDeclar = parentDeclar.parentPath;
        if (!maybeExportDeclar.isExportDeclaration()) {
          return;
        }
        if (maybeExportDeclar.isExportDefaultDeclaration()) {
          const {
            declaration
          } = maybeExportDeclar.node;
          if (t3.isDeclaration(declaration) && !declaration.id) {
            return;
          }
        }
        if (maybeExportDeclar.isExportAllDeclaration()) {
          return;
        }
        (0, _helperSplitExportDeclaration.default)(maybeExportDeclar);
      }
      maybeConvertFromClassFunctionDeclaration(path) {
        return path;
      }
      maybeConvertFromClassFunctionExpression(path) {
        return path;
      }
      rename() {
        const {
          binding,
          oldName,
          newName
        } = this;
        const {
          scope,
          path
        } = binding;
        const parentDeclar = path.find((path2) => path2.isDeclaration() || path2.isFunctionExpression() || path2.isClassExpression());
        if (parentDeclar) {
          const bindingIds = parentDeclar.getOuterBindingIdentifiers();
          if (bindingIds[oldName] === binding.identifier) {
            this.maybeConvertFromExportDeclaration(parentDeclar);
          }
        }
        const blockToTraverse = arguments[0] || scope.block;
        (0, _traverseNode.traverseNode)(blockToTraverse, (0, _visitors.explode)(renameVisitor), scope, this, scope.path, {
          discriminant: true
        });
        if (!arguments[0]) {
          scope.removeOwnBinding(oldName);
          scope.bindings[newName] = binding;
          this.binding.identifier.name = newName;
        }
        if (parentDeclar) {
          this.maybeConvertFromClassFunctionDeclaration(path);
          this.maybeConvertFromClassFunctionExpression(path);
        }
      }
    };
    exports.default = Renamer;
  }
});

// node_modules/@babel/traverse/lib/scope/binding.js
var require_binding = __commonJS({
  "node_modules/@babel/traverse/lib/scope/binding.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var Binding = class {
      constructor({
        identifier,
        scope,
        path,
        kind
      }) {
        this.identifier = void 0;
        this.scope = void 0;
        this.path = void 0;
        this.kind = void 0;
        this.constantViolations = [];
        this.constant = true;
        this.referencePaths = [];
        this.referenced = false;
        this.references = 0;
        this.identifier = identifier;
        this.scope = scope;
        this.path = path;
        this.kind = kind;
        if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path || (() => {
          throw new Error("Internal Babel error: unreachable ");
        })())) {
          this.reassign(path);
        }
        this.clearValue();
      }
      deoptValue() {
        this.clearValue();
        this.hasDeoptedValue = true;
      }
      setValue(value2) {
        if (this.hasDeoptedValue)
          return;
        this.hasValue = true;
        this.value = value2;
      }
      clearValue() {
        this.hasDeoptedValue = false;
        this.hasValue = false;
        this.value = null;
      }
      reassign(path) {
        this.constant = false;
        if (this.constantViolations.indexOf(path) !== -1) {
          return;
        }
        this.constantViolations.push(path);
      }
      reference(path) {
        if (this.referencePaths.indexOf(path) !== -1) {
          return;
        }
        this.referenced = true;
        this.references++;
        this.referencePaths.push(path);
      }
      dereference() {
        this.references--;
        this.referenced = !!this.references;
      }
    };
    exports.default = Binding;
    function isDeclaredInLoop(path) {
      for (let {
        parentPath,
        key: key2
      } = path; parentPath; {
        parentPath,
        key: key2
      } = parentPath) {
        if (parentPath.isFunctionParent())
          return false;
        if (parentPath.isWhile() || parentPath.isForXStatement() || parentPath.isForStatement() && key2 === "body") {
          return true;
        }
      }
      return false;
    }
  }
});

// node_modules/globals/globals.json
var require_globals = __commonJS({
  "node_modules/globals/globals.json"(exports, module2) {
    module2.exports = {
      builtin: {
        Array: false,
        ArrayBuffer: false,
        Atomics: false,
        BigInt: false,
        BigInt64Array: false,
        BigUint64Array: false,
        Boolean: false,
        constructor: false,
        DataView: false,
        Date: false,
        decodeURI: false,
        decodeURIComponent: false,
        encodeURI: false,
        encodeURIComponent: false,
        Error: false,
        escape: false,
        eval: false,
        EvalError: false,
        Float32Array: false,
        Float64Array: false,
        Function: false,
        globalThis: false,
        hasOwnProperty: false,
        Infinity: false,
        Int16Array: false,
        Int32Array: false,
        Int8Array: false,
        isFinite: false,
        isNaN: false,
        isPrototypeOf: false,
        JSON: false,
        Map: false,
        Math: false,
        NaN: false,
        Number: false,
        Object: false,
        parseFloat: false,
        parseInt: false,
        Promise: false,
        propertyIsEnumerable: false,
        Proxy: false,
        RangeError: false,
        ReferenceError: false,
        Reflect: false,
        RegExp: false,
        Set: false,
        SharedArrayBuffer: false,
        String: false,
        Symbol: false,
        SyntaxError: false,
        toLocaleString: false,
        toString: false,
        TypeError: false,
        Uint16Array: false,
        Uint32Array: false,
        Uint8Array: false,
        Uint8ClampedArray: false,
        undefined: false,
        unescape: false,
        URIError: false,
        valueOf: false,
        WeakMap: false,
        WeakSet: false
      },
      es5: {
        Array: false,
        Boolean: false,
        constructor: false,
        Date: false,
        decodeURI: false,
        decodeURIComponent: false,
        encodeURI: false,
        encodeURIComponent: false,
        Error: false,
        escape: false,
        eval: false,
        EvalError: false,
        Function: false,
        hasOwnProperty: false,
        Infinity: false,
        isFinite: false,
        isNaN: false,
        isPrototypeOf: false,
        JSON: false,
        Math: false,
        NaN: false,
        Number: false,
        Object: false,
        parseFloat: false,
        parseInt: false,
        propertyIsEnumerable: false,
        RangeError: false,
        ReferenceError: false,
        RegExp: false,
        String: false,
        SyntaxError: false,
        toLocaleString: false,
        toString: false,
        TypeError: false,
        undefined: false,
        unescape: false,
        URIError: false,
        valueOf: false
      },
      es2015: {
        Array: false,
        ArrayBuffer: false,
        Boolean: false,
        constructor: false,
        DataView: false,
        Date: false,
        decodeURI: false,
        decodeURIComponent: false,
        encodeURI: false,
        encodeURIComponent: false,
        Error: false,
        escape: false,
        eval: false,
        EvalError: false,
        Float32Array: false,
        Float64Array: false,
        Function: false,
        hasOwnProperty: false,
        Infinity: false,
        Int16Array: false,
        Int32Array: false,
        Int8Array: false,
        isFinite: false,
        isNaN: false,
        isPrototypeOf: false,
        JSON: false,
        Map: false,
        Math: false,
        NaN: false,
        Number: false,
        Object: false,
        parseFloat: false,
        parseInt: false,
        Promise: false,
        propertyIsEnumerable: false,
        Proxy: false,
        RangeError: false,
        ReferenceError: false,
        Reflect: false,
        RegExp: false,
        Set: false,
        String: false,
        Symbol: false,
        SyntaxError: false,
        toLocaleString: false,
        toString: false,
        TypeError: false,
        Uint16Array: false,
        Uint32Array: false,
        Uint8Array: false,
        Uint8ClampedArray: false,
        undefined: false,
        unescape: false,
        URIError: false,
        valueOf: false,
        WeakMap: false,
        WeakSet: false
      },
      es2017: {
        Array: false,
        ArrayBuffer: false,
        Atomics: false,
        Boolean: false,
        constructor: false,
        DataView: false,
        Date: false,
        decodeURI: false,
        decodeURIComponent: false,
        encodeURI: false,
        encodeURIComponent: false,
        Error: false,
        escape: false,
        eval: false,
        EvalError: false,
        Float32Array: false,
        Float64Array: false,
        Function: false,
        hasOwnProperty: false,
        Infinity: false,
        Int16Array: false,
        Int32Array: false,
        Int8Array: false,
        isFinite: false,
        isNaN: false,
        isPrototypeOf: false,
        JSON: false,
        Map: false,
        Math: false,
        NaN: false,
        Number: false,
        Object: false,
        parseFloat: false,
        parseInt: false,
        Promise: false,
        propertyIsEnumerable: false,
        Proxy: false,
        RangeError: false,
        ReferenceError: false,
        Reflect: false,
        RegExp: false,
        Set: false,
        SharedArrayBuffer: false,
        String: false,
        Symbol: false,
        SyntaxError: false,
        toLocaleString: false,
        toString: false,
        TypeError: false,
        Uint16Array: false,
        Uint32Array: false,
        Uint8Array: false,
        Uint8ClampedArray: false,
        undefined: false,
        unescape: false,
        URIError: false,
        valueOf: false,
        WeakMap: false,
        WeakSet: false
      },
      browser: {
        AbortController: false,
        AbortSignal: false,
        addEventListener: false,
        alert: false,
        AnalyserNode: false,
        Animation: false,
        AnimationEffectReadOnly: false,
        AnimationEffectTiming: false,
        AnimationEffectTimingReadOnly: false,
        AnimationEvent: false,
        AnimationPlaybackEvent: false,
        AnimationTimeline: false,
        applicationCache: false,
        ApplicationCache: false,
        ApplicationCacheErrorEvent: false,
        atob: false,
        Attr: false,
        Audio: false,
        AudioBuffer: false,
        AudioBufferSourceNode: false,
        AudioContext: false,
        AudioDestinationNode: false,
        AudioListener: false,
        AudioNode: false,
        AudioParam: false,
        AudioProcessingEvent: false,
        AudioScheduledSourceNode: false,
        "AudioWorkletGlobalScope ": false,
        AudioWorkletNode: false,
        AudioWorkletProcessor: false,
        BarProp: false,
        BaseAudioContext: false,
        BatteryManager: false,
        BeforeUnloadEvent: false,
        BiquadFilterNode: false,
        Blob: false,
        BlobEvent: false,
        blur: false,
        BroadcastChannel: false,
        btoa: false,
        BudgetService: false,
        ByteLengthQueuingStrategy: false,
        Cache: false,
        caches: false,
        CacheStorage: false,
        cancelAnimationFrame: false,
        cancelIdleCallback: false,
        CanvasCaptureMediaStreamTrack: false,
        CanvasGradient: false,
        CanvasPattern: false,
        CanvasRenderingContext2D: false,
        ChannelMergerNode: false,
        ChannelSplitterNode: false,
        CharacterData: false,
        clearInterval: false,
        clearTimeout: false,
        clientInformation: false,
        ClipboardEvent: false,
        close: false,
        closed: false,
        CloseEvent: false,
        Comment: false,
        CompositionEvent: false,
        confirm: false,
        console: false,
        ConstantSourceNode: false,
        ConvolverNode: false,
        CountQueuingStrategy: false,
        createImageBitmap: false,
        Credential: false,
        CredentialsContainer: false,
        crypto: false,
        Crypto: false,
        CryptoKey: false,
        CSS: false,
        CSSConditionRule: false,
        CSSFontFaceRule: false,
        CSSGroupingRule: false,
        CSSImportRule: false,
        CSSKeyframeRule: false,
        CSSKeyframesRule: false,
        CSSMediaRule: false,
        CSSNamespaceRule: false,
        CSSPageRule: false,
        CSSRule: false,
        CSSRuleList: false,
        CSSStyleDeclaration: false,
        CSSStyleRule: false,
        CSSStyleSheet: false,
        CSSSupportsRule: false,
        CustomElementRegistry: false,
        customElements: false,
        CustomEvent: false,
        DataTransfer: false,
        DataTransferItem: false,
        DataTransferItemList: false,
        defaultstatus: false,
        defaultStatus: false,
        DelayNode: false,
        DeviceMotionEvent: false,
        DeviceOrientationEvent: false,
        devicePixelRatio: false,
        dispatchEvent: false,
        document: false,
        Document: false,
        DocumentFragment: false,
        DocumentType: false,
        DOMError: false,
        DOMException: false,
        DOMImplementation: false,
        DOMMatrix: false,
        DOMMatrixReadOnly: false,
        DOMParser: false,
        DOMPoint: false,
        DOMPointReadOnly: false,
        DOMQuad: false,
        DOMRect: false,
        DOMRectReadOnly: false,
        DOMStringList: false,
        DOMStringMap: false,
        DOMTokenList: false,
        DragEvent: false,
        DynamicsCompressorNode: false,
        Element: false,
        ErrorEvent: false,
        event: false,
        Event: false,
        EventSource: false,
        EventTarget: false,
        external: false,
        fetch: false,
        File: false,
        FileList: false,
        FileReader: false,
        find: false,
        focus: false,
        FocusEvent: false,
        FontFace: false,
        FontFaceSetLoadEvent: false,
        FormData: false,
        frameElement: false,
        frames: false,
        GainNode: false,
        Gamepad: false,
        GamepadButton: false,
        GamepadEvent: false,
        getComputedStyle: false,
        getSelection: false,
        HashChangeEvent: false,
        Headers: false,
        history: false,
        History: false,
        HTMLAllCollection: false,
        HTMLAnchorElement: false,
        HTMLAreaElement: false,
        HTMLAudioElement: false,
        HTMLBaseElement: false,
        HTMLBodyElement: false,
        HTMLBRElement: false,
        HTMLButtonElement: false,
        HTMLCanvasElement: false,
        HTMLCollection: false,
        HTMLContentElement: false,
        HTMLDataElement: false,
        HTMLDataListElement: false,
        HTMLDetailsElement: false,
        HTMLDialogElement: false,
        HTMLDirectoryElement: false,
        HTMLDivElement: false,
        HTMLDListElement: false,
        HTMLDocument: false,
        HTMLElement: false,
        HTMLEmbedElement: false,
        HTMLFieldSetElement: false,
        HTMLFontElement: false,
        HTMLFormControlsCollection: false,
        HTMLFormElement: false,
        HTMLFrameElement: false,
        HTMLFrameSetElement: false,
        HTMLHeadElement: false,
        HTMLHeadingElement: false,
        HTMLHRElement: false,
        HTMLHtmlElement: false,
        HTMLIFrameElement: false,
        HTMLImageElement: false,
        HTMLInputElement: false,
        HTMLLabelElement: false,
        HTMLLegendElement: false,
        HTMLLIElement: false,
        HTMLLinkElement: false,
        HTMLMapElement: false,
        HTMLMarqueeElement: false,
        HTMLMediaElement: false,
        HTMLMenuElement: false,
        HTMLMetaElement: false,
        HTMLMeterElement: false,
        HTMLModElement: false,
        HTMLObjectElement: false,
        HTMLOListElement: false,
        HTMLOptGroupElement: false,
        HTMLOptionElement: false,
        HTMLOptionsCollection: false,
        HTMLOutputElement: false,
        HTMLParagraphElement: false,
        HTMLParamElement: false,
        HTMLPictureElement: false,
        HTMLPreElement: false,
        HTMLProgressElement: false,
        HTMLQuoteElement: false,
        HTMLScriptElement: false,
        HTMLSelectElement: false,
        HTMLShadowElement: false,
        HTMLSlotElement: false,
        HTMLSourceElement: false,
        HTMLSpanElement: false,
        HTMLStyleElement: false,
        HTMLTableCaptionElement: false,
        HTMLTableCellElement: false,
        HTMLTableColElement: false,
        HTMLTableElement: false,
        HTMLTableRowElement: false,
        HTMLTableSectionElement: false,
        HTMLTemplateElement: false,
        HTMLTextAreaElement: false,
        HTMLTimeElement: false,
        HTMLTitleElement: false,
        HTMLTrackElement: false,
        HTMLUListElement: false,
        HTMLUnknownElement: false,
        HTMLVideoElement: false,
        IDBCursor: false,
        IDBCursorWithValue: false,
        IDBDatabase: false,
        IDBFactory: false,
        IDBIndex: false,
        IDBKeyRange: false,
        IDBObjectStore: false,
        IDBOpenDBRequest: false,
        IDBRequest: false,
        IDBTransaction: false,
        IDBVersionChangeEvent: false,
        IdleDeadline: false,
        IIRFilterNode: false,
        Image: false,
        ImageBitmap: false,
        ImageBitmapRenderingContext: false,
        ImageCapture: false,
        ImageData: false,
        indexedDB: false,
        innerHeight: false,
        innerWidth: false,
        InputEvent: false,
        IntersectionObserver: false,
        IntersectionObserverEntry: false,
        Intl: false,
        isSecureContext: false,
        KeyboardEvent: false,
        KeyframeEffect: false,
        KeyframeEffectReadOnly: false,
        length: false,
        localStorage: false,
        location: true,
        Location: false,
        locationbar: false,
        matchMedia: false,
        MediaDeviceInfo: false,
        MediaDevices: false,
        MediaElementAudioSourceNode: false,
        MediaEncryptedEvent: false,
        MediaError: false,
        MediaKeyMessageEvent: false,
        MediaKeySession: false,
        MediaKeyStatusMap: false,
        MediaKeySystemAccess: false,
        MediaList: false,
        MediaQueryList: false,
        MediaQueryListEvent: false,
        MediaRecorder: false,
        MediaSettingsRange: false,
        MediaSource: false,
        MediaStream: false,
        MediaStreamAudioDestinationNode: false,
        MediaStreamAudioSourceNode: false,
        MediaStreamEvent: false,
        MediaStreamTrack: false,
        MediaStreamTrackEvent: false,
        menubar: false,
        MessageChannel: false,
        MessageEvent: false,
        MessagePort: false,
        MIDIAccess: false,
        MIDIConnectionEvent: false,
        MIDIInput: false,
        MIDIInputMap: false,
        MIDIMessageEvent: false,
        MIDIOutput: false,
        MIDIOutputMap: false,
        MIDIPort: false,
        MimeType: false,
        MimeTypeArray: false,
        MouseEvent: false,
        moveBy: false,
        moveTo: false,
        MutationEvent: false,
        MutationObserver: false,
        MutationRecord: false,
        name: false,
        NamedNodeMap: false,
        NavigationPreloadManager: false,
        navigator: false,
        Navigator: false,
        NetworkInformation: false,
        Node: false,
        NodeFilter: false,
        NodeIterator: false,
        NodeList: false,
        Notification: false,
        OfflineAudioCompletionEvent: false,
        OfflineAudioContext: false,
        offscreenBuffering: false,
        OffscreenCanvas: true,
        onabort: true,
        onafterprint: true,
        onanimationend: true,
        onanimationiteration: true,
        onanimationstart: true,
        onappinstalled: true,
        onauxclick: true,
        onbeforeinstallprompt: true,
        onbeforeprint: true,
        onbeforeunload: true,
        onblur: true,
        oncancel: true,
        oncanplay: true,
        oncanplaythrough: true,
        onchange: true,
        onclick: true,
        onclose: true,
        oncontextmenu: true,
        oncuechange: true,
        ondblclick: true,
        ondevicemotion: true,
        ondeviceorientation: true,
        ondeviceorientationabsolute: true,
        ondrag: true,
        ondragend: true,
        ondragenter: true,
        ondragleave: true,
        ondragover: true,
        ondragstart: true,
        ondrop: true,
        ondurationchange: true,
        onemptied: true,
        onended: true,
        onerror: true,
        onfocus: true,
        ongotpointercapture: true,
        onhashchange: true,
        oninput: true,
        oninvalid: true,
        onkeydown: true,
        onkeypress: true,
        onkeyup: true,
        onlanguagechange: true,
        onload: true,
        onloadeddata: true,
        onloadedmetadata: true,
        onloadstart: true,
        onlostpointercapture: true,
        onmessage: true,
        onmessageerror: true,
        onmousedown: true,
        onmouseenter: true,
        onmouseleave: true,
        onmousemove: true,
        onmouseout: true,
        onmouseover: true,
        onmouseup: true,
        onmousewheel: true,
        onoffline: true,
        ononline: true,
        onpagehide: true,
        onpageshow: true,
        onpause: true,
        onplay: true,
        onplaying: true,
        onpointercancel: true,
        onpointerdown: true,
        onpointerenter: true,
        onpointerleave: true,
        onpointermove: true,
        onpointerout: true,
        onpointerover: true,
        onpointerup: true,
        onpopstate: true,
        onprogress: true,
        onratechange: true,
        onrejectionhandled: true,
        onreset: true,
        onresize: true,
        onscroll: true,
        onsearch: true,
        onseeked: true,
        onseeking: true,
        onselect: true,
        onstalled: true,
        onstorage: true,
        onsubmit: true,
        onsuspend: true,
        ontimeupdate: true,
        ontoggle: true,
        ontransitionend: true,
        onunhandledrejection: true,
        onunload: true,
        onvolumechange: true,
        onwaiting: true,
        onwheel: true,
        open: false,
        openDatabase: false,
        opener: false,
        Option: false,
        origin: false,
        OscillatorNode: false,
        outerHeight: false,
        outerWidth: false,
        PageTransitionEvent: false,
        pageXOffset: false,
        pageYOffset: false,
        PannerNode: false,
        parent: false,
        Path2D: false,
        PaymentAddress: false,
        PaymentRequest: false,
        PaymentRequestUpdateEvent: false,
        PaymentResponse: false,
        performance: false,
        Performance: false,
        PerformanceEntry: false,
        PerformanceLongTaskTiming: false,
        PerformanceMark: false,
        PerformanceMeasure: false,
        PerformanceNavigation: false,
        PerformanceNavigationTiming: false,
        PerformanceObserver: false,
        PerformanceObserverEntryList: false,
        PerformancePaintTiming: false,
        PerformanceResourceTiming: false,
        PerformanceTiming: false,
        PeriodicWave: false,
        Permissions: false,
        PermissionStatus: false,
        personalbar: false,
        PhotoCapabilities: false,
        Plugin: false,
        PluginArray: false,
        PointerEvent: false,
        PopStateEvent: false,
        postMessage: false,
        Presentation: false,
        PresentationAvailability: false,
        PresentationConnection: false,
        PresentationConnectionAvailableEvent: false,
        PresentationConnectionCloseEvent: false,
        PresentationConnectionList: false,
        PresentationReceiver: false,
        PresentationRequest: false,
        print: false,
        ProcessingInstruction: false,
        ProgressEvent: false,
        PromiseRejectionEvent: false,
        prompt: false,
        PushManager: false,
        PushSubscription: false,
        PushSubscriptionOptions: false,
        queueMicrotask: false,
        RadioNodeList: false,
        Range: false,
        ReadableStream: false,
        registerProcessor: false,
        RemotePlayback: false,
        removeEventListener: false,
        Request: false,
        requestAnimationFrame: false,
        requestIdleCallback: false,
        resizeBy: false,
        ResizeObserver: false,
        ResizeObserverEntry: false,
        resizeTo: false,
        Response: false,
        RTCCertificate: false,
        RTCDataChannel: false,
        RTCDataChannelEvent: false,
        RTCDtlsTransport: false,
        RTCIceCandidate: false,
        RTCIceGatherer: false,
        RTCIceTransport: false,
        RTCPeerConnection: false,
        RTCPeerConnectionIceEvent: false,
        RTCRtpContributingSource: false,
        RTCRtpReceiver: false,
        RTCRtpSender: false,
        RTCSctpTransport: false,
        RTCSessionDescription: false,
        RTCStatsReport: false,
        RTCTrackEvent: false,
        screen: false,
        Screen: false,
        screenLeft: false,
        ScreenOrientation: false,
        screenTop: false,
        screenX: false,
        screenY: false,
        ScriptProcessorNode: false,
        scroll: false,
        scrollbars: false,
        scrollBy: false,
        scrollTo: false,
        scrollX: false,
        scrollY: false,
        SecurityPolicyViolationEvent: false,
        Selection: false,
        self: false,
        ServiceWorker: false,
        ServiceWorkerContainer: false,
        ServiceWorkerRegistration: false,
        sessionStorage: false,
        setInterval: false,
        setTimeout: false,
        ShadowRoot: false,
        SharedWorker: false,
        SourceBuffer: false,
        SourceBufferList: false,
        speechSynthesis: false,
        SpeechSynthesisEvent: false,
        SpeechSynthesisUtterance: false,
        StaticRange: false,
        status: false,
        statusbar: false,
        StereoPannerNode: false,
        stop: false,
        Storage: false,
        StorageEvent: false,
        StorageManager: false,
        styleMedia: false,
        StyleSheet: false,
        StyleSheetList: false,
        SubtleCrypto: false,
        SVGAElement: false,
        SVGAngle: false,
        SVGAnimatedAngle: false,
        SVGAnimatedBoolean: false,
        SVGAnimatedEnumeration: false,
        SVGAnimatedInteger: false,
        SVGAnimatedLength: false,
        SVGAnimatedLengthList: false,
        SVGAnimatedNumber: false,
        SVGAnimatedNumberList: false,
        SVGAnimatedPreserveAspectRatio: false,
        SVGAnimatedRect: false,
        SVGAnimatedString: false,
        SVGAnimatedTransformList: false,
        SVGAnimateElement: false,
        SVGAnimateMotionElement: false,
        SVGAnimateTransformElement: false,
        SVGAnimationElement: false,
        SVGCircleElement: false,
        SVGClipPathElement: false,
        SVGComponentTransferFunctionElement: false,
        SVGDefsElement: false,
        SVGDescElement: false,
        SVGDiscardElement: false,
        SVGElement: false,
        SVGEllipseElement: false,
        SVGFEBlendElement: false,
        SVGFEColorMatrixElement: false,
        SVGFEComponentTransferElement: false,
        SVGFECompositeElement: false,
        SVGFEConvolveMatrixElement: false,
        SVGFEDiffuseLightingElement: false,
        SVGFEDisplacementMapElement: false,
        SVGFEDistantLightElement: false,
        SVGFEDropShadowElement: false,
        SVGFEFloodElement: false,
        SVGFEFuncAElement: false,
        SVGFEFuncBElement: false,
        SVGFEFuncGElement: false,
        SVGFEFuncRElement: false,
        SVGFEGaussianBlurElement: false,
        SVGFEImageElement: false,
        SVGFEMergeElement: false,
        SVGFEMergeNodeElement: false,
        SVGFEMorphologyElement: false,
        SVGFEOffsetElement: false,
        SVGFEPointLightElement: false,
        SVGFESpecularLightingElement: false,
        SVGFESpotLightElement: false,
        SVGFETileElement: false,
        SVGFETurbulenceElement: false,
        SVGFilterElement: false,
        SVGForeignObjectElement: false,
        SVGGElement: false,
        SVGGeometryElement: false,
        SVGGradientElement: false,
        SVGGraphicsElement: false,
        SVGImageElement: false,
        SVGLength: false,
        SVGLengthList: false,
        SVGLinearGradientElement: false,
        SVGLineElement: false,
        SVGMarkerElement: false,
        SVGMaskElement: false,
        SVGMatrix: false,
        SVGMetadataElement: false,
        SVGMPathElement: false,
        SVGNumber: false,
        SVGNumberList: false,
        SVGPathElement: false,
        SVGPatternElement: false,
        SVGPoint: false,
        SVGPointList: false,
        SVGPolygonElement: false,
        SVGPolylineElement: false,
        SVGPreserveAspectRatio: false,
        SVGRadialGradientElement: false,
        SVGRect: false,
        SVGRectElement: false,
        SVGScriptElement: false,
        SVGSetElement: false,
        SVGStopElement: false,
        SVGStringList: false,
        SVGStyleElement: false,
        SVGSVGElement: false,
        SVGSwitchElement: false,
        SVGSymbolElement: false,
        SVGTextContentElement: false,
        SVGTextElement: false,
        SVGTextPathElement: false,
        SVGTextPositioningElement: false,
        SVGTitleElement: false,
        SVGTransform: false,
        SVGTransformList: false,
        SVGTSpanElement: false,
        SVGUnitTypes: false,
        SVGUseElement: false,
        SVGViewElement: false,
        TaskAttributionTiming: false,
        Text: false,
        TextDecoder: false,
        TextEncoder: false,
        TextEvent: false,
        TextMetrics: false,
        TextTrack: false,
        TextTrackCue: false,
        TextTrackCueList: false,
        TextTrackList: false,
        TimeRanges: false,
        toolbar: false,
        top: false,
        Touch: false,
        TouchEvent: false,
        TouchList: false,
        TrackEvent: false,
        TransitionEvent: false,
        TreeWalker: false,
        UIEvent: false,
        URL: false,
        URLSearchParams: false,
        ValidityState: false,
        visualViewport: false,
        VisualViewport: false,
        VTTCue: false,
        WaveShaperNode: false,
        WebAssembly: false,
        WebGL2RenderingContext: false,
        WebGLActiveInfo: false,
        WebGLBuffer: false,
        WebGLContextEvent: false,
        WebGLFramebuffer: false,
        WebGLProgram: false,
        WebGLQuery: false,
        WebGLRenderbuffer: false,
        WebGLRenderingContext: false,
        WebGLSampler: false,
        WebGLShader: false,
        WebGLShaderPrecisionFormat: false,
        WebGLSync: false,
        WebGLTexture: false,
        WebGLTransformFeedback: false,
        WebGLUniformLocation: false,
        WebGLVertexArrayObject: false,
        WebSocket: false,
        WheelEvent: false,
        window: false,
        Window: false,
        Worker: false,
        WritableStream: false,
        XMLDocument: false,
        XMLHttpRequest: false,
        XMLHttpRequestEventTarget: false,
        XMLHttpRequestUpload: false,
        XMLSerializer: false,
        XPathEvaluator: false,
        XPathExpression: false,
        XPathResult: false,
        XSLTProcessor: false
      },
      worker: {
        addEventListener: false,
        applicationCache: false,
        atob: false,
        Blob: false,
        BroadcastChannel: false,
        btoa: false,
        Cache: false,
        caches: false,
        clearInterval: false,
        clearTimeout: false,
        close: true,
        console: false,
        fetch: false,
        FileReaderSync: false,
        FormData: false,
        Headers: false,
        IDBCursor: false,
        IDBCursorWithValue: false,
        IDBDatabase: false,
        IDBFactory: false,
        IDBIndex: false,
        IDBKeyRange: false,
        IDBObjectStore: false,
        IDBOpenDBRequest: false,
        IDBRequest: false,
        IDBTransaction: false,
        IDBVersionChangeEvent: false,
        ImageData: false,
        importScripts: true,
        indexedDB: false,
        location: false,
        MessageChannel: false,
        MessagePort: false,
        name: false,
        navigator: false,
        Notification: false,
        onclose: true,
        onconnect: true,
        onerror: true,
        onlanguagechange: true,
        onmessage: true,
        onoffline: true,
        ononline: true,
        onrejectionhandled: true,
        onunhandledrejection: true,
        performance: false,
        Performance: false,
        PerformanceEntry: false,
        PerformanceMark: false,
        PerformanceMeasure: false,
        PerformanceNavigation: false,
        PerformanceResourceTiming: false,
        PerformanceTiming: false,
        postMessage: true,
        Promise: false,
        queueMicrotask: false,
        removeEventListener: false,
        Request: false,
        Response: false,
        self: true,
        ServiceWorkerRegistration: false,
        setInterval: false,
        setTimeout: false,
        TextDecoder: false,
        TextEncoder: false,
        URL: false,
        URLSearchParams: false,
        WebSocket: false,
        Worker: false,
        WorkerGlobalScope: false,
        XMLHttpRequest: false
      },
      node: {
        __dirname: false,
        __filename: false,
        Buffer: false,
        clearImmediate: false,
        clearInterval: false,
        clearTimeout: false,
        console: false,
        exports: true,
        global: false,
        Intl: false,
        module: false,
        process: false,
        queueMicrotask: false,
        require: false,
        setImmediate: false,
        setInterval: false,
        setTimeout: false,
        TextDecoder: false,
        TextEncoder: false,
        URL: false,
        URLSearchParams: false
      },
      commonjs: {
        exports: true,
        global: false,
        module: false,
        require: false
      },
      amd: {
        define: false,
        require: false
      },
      mocha: {
        after: false,
        afterEach: false,
        before: false,
        beforeEach: false,
        context: false,
        describe: false,
        it: false,
        mocha: false,
        run: false,
        setup: false,
        specify: false,
        suite: false,
        suiteSetup: false,
        suiteTeardown: false,
        teardown: false,
        test: false,
        xcontext: false,
        xdescribe: false,
        xit: false,
        xspecify: false
      },
      jasmine: {
        afterAll: false,
        afterEach: false,
        beforeAll: false,
        beforeEach: false,
        describe: false,
        expect: false,
        fail: false,
        fdescribe: false,
        fit: false,
        it: false,
        jasmine: false,
        pending: false,
        runs: false,
        spyOn: false,
        spyOnProperty: false,
        waits: false,
        waitsFor: false,
        xdescribe: false,
        xit: false
      },
      jest: {
        afterAll: false,
        afterEach: false,
        beforeAll: false,
        beforeEach: false,
        describe: false,
        expect: false,
        fdescribe: false,
        fit: false,
        it: false,
        jest: false,
        pit: false,
        require: false,
        test: false,
        xdescribe: false,
        xit: false,
        xtest: false
      },
      qunit: {
        asyncTest: false,
        deepEqual: false,
        equal: false,
        expect: false,
        module: false,
        notDeepEqual: false,
        notEqual: false,
        notOk: false,
        notPropEqual: false,
        notStrictEqual: false,
        ok: false,
        propEqual: false,
        QUnit: false,
        raises: false,
        start: false,
        stop: false,
        strictEqual: false,
        test: false,
        throws: false
      },
      phantomjs: {
        console: true,
        exports: true,
        phantom: true,
        require: true,
        WebPage: true
      },
      couch: {
        emit: false,
        exports: false,
        getRow: false,
        log: false,
        module: false,
        provides: false,
        require: false,
        respond: false,
        send: false,
        start: false,
        sum: false
      },
      rhino: {
        defineClass: false,
        deserialize: false,
        gc: false,
        help: false,
        importClass: false,
        importPackage: false,
        java: false,
        load: false,
        loadClass: false,
        Packages: false,
        print: false,
        quit: false,
        readFile: false,
        readUrl: false,
        runCommand: false,
        seal: false,
        serialize: false,
        spawn: false,
        sync: false,
        toint32: false,
        version: false
      },
      nashorn: {
        __DIR__: false,
        __FILE__: false,
        __LINE__: false,
        com: false,
        edu: false,
        exit: false,
        java: false,
        Java: false,
        javafx: false,
        JavaImporter: false,
        javax: false,
        JSAdapter: false,
        load: false,
        loadWithNewGlobal: false,
        org: false,
        Packages: false,
        print: false,
        quit: false
      },
      wsh: {
        ActiveXObject: true,
        Enumerator: true,
        GetObject: true,
        ScriptEngine: true,
        ScriptEngineBuildVersion: true,
        ScriptEngineMajorVersion: true,
        ScriptEngineMinorVersion: true,
        VBArray: true,
        WScript: true,
        WSH: true,
        XDomainRequest: true
      },
      jquery: {
        $: false,
        jQuery: false
      },
      yui: {
        YAHOO: false,
        YAHOO_config: false,
        YUI: false,
        YUI_config: false
      },
      shelljs: {
        cat: false,
        cd: false,
        chmod: false,
        config: false,
        cp: false,
        dirs: false,
        echo: false,
        env: false,
        error: false,
        exec: false,
        exit: false,
        find: false,
        grep: false,
        ln: false,
        ls: false,
        mkdir: false,
        mv: false,
        popd: false,
        pushd: false,
        pwd: false,
        rm: false,
        sed: false,
        set: false,
        target: false,
        tempdir: false,
        test: false,
        touch: false,
        which: false
      },
      prototypejs: {
        $: false,
        $$: false,
        $A: false,
        $break: false,
        $continue: false,
        $F: false,
        $H: false,
        $R: false,
        $w: false,
        Abstract: false,
        Ajax: false,
        Autocompleter: false,
        Builder: false,
        Class: false,
        Control: false,
        Draggable: false,
        Draggables: false,
        Droppables: false,
        Effect: false,
        Element: false,
        Enumerable: false,
        Event: false,
        Field: false,
        Form: false,
        Hash: false,
        Insertion: false,
        ObjectRange: false,
        PeriodicalExecuter: false,
        Position: false,
        Prototype: false,
        Scriptaculous: false,
        Selector: false,
        Sortable: false,
        SortableObserver: false,
        Sound: false,
        Template: false,
        Toggle: false,
        Try: false
      },
      meteor: {
        _: false,
        $: false,
        Accounts: false,
        AccountsClient: false,
        AccountsCommon: false,
        AccountsServer: false,
        App: false,
        Assets: false,
        Blaze: false,
        check: false,
        Cordova: false,
        DDP: false,
        DDPRateLimiter: false,
        DDPServer: false,
        Deps: false,
        EJSON: false,
        Email: false,
        HTTP: false,
        Log: false,
        Match: false,
        Meteor: false,
        Mongo: false,
        MongoInternals: false,
        Npm: false,
        Package: false,
        Plugin: false,
        process: false,
        Random: false,
        ReactiveDict: false,
        ReactiveVar: false,
        Router: false,
        ServiceConfiguration: false,
        Session: false,
        share: false,
        Spacebars: false,
        Template: false,
        Tinytest: false,
        Tracker: false,
        UI: false,
        Utils: false,
        WebApp: false,
        WebAppInternals: false
      },
      mongo: {
        _isWindows: false,
        _rand: false,
        BulkWriteResult: false,
        cat: false,
        cd: false,
        connect: false,
        db: false,
        getHostName: false,
        getMemInfo: false,
        hostname: false,
        ISODate: false,
        listFiles: false,
        load: false,
        ls: false,
        md5sumFile: false,
        mkdir: false,
        Mongo: false,
        NumberInt: false,
        NumberLong: false,
        ObjectId: false,
        PlanCache: false,
        print: false,
        printjson: false,
        pwd: false,
        quit: false,
        removeFile: false,
        rs: false,
        sh: false,
        UUID: false,
        version: false,
        WriteResult: false
      },
      applescript: {
        $: false,
        Application: false,
        Automation: false,
        console: false,
        delay: false,
        Library: false,
        ObjC: false,
        ObjectSpecifier: false,
        Path: false,
        Progress: false,
        Ref: false
      },
      serviceworker: {
        addEventListener: false,
        applicationCache: false,
        atob: false,
        Blob: false,
        BroadcastChannel: false,
        btoa: false,
        Cache: false,
        caches: false,
        CacheStorage: false,
        clearInterval: false,
        clearTimeout: false,
        Client: false,
        clients: false,
        Clients: false,
        close: true,
        console: false,
        ExtendableEvent: false,
        ExtendableMessageEvent: false,
        fetch: false,
        FetchEvent: false,
        FileReaderSync: false,
        FormData: false,
        Headers: false,
        IDBCursor: false,
        IDBCursorWithValue: false,
        IDBDatabase: false,
        IDBFactory: false,
        IDBIndex: false,
        IDBKeyRange: false,
        IDBObjectStore: false,
        IDBOpenDBRequest: false,
        IDBRequest: false,
        IDBTransaction: false,
        IDBVersionChangeEvent: false,
        ImageData: false,
        importScripts: false,
        indexedDB: false,
        location: false,
        MessageChannel: false,
        MessagePort: false,
        name: false,
        navigator: false,
        Notification: false,
        onclose: true,
        onconnect: true,
        onerror: true,
        onfetch: true,
        oninstall: true,
        onlanguagechange: true,
        onmessage: true,
        onmessageerror: true,
        onnotificationclick: true,
        onnotificationclose: true,
        onoffline: true,
        ononline: true,
        onpush: true,
        onpushsubscriptionchange: true,
        onrejectionhandled: true,
        onsync: true,
        onunhandledrejection: true,
        performance: false,
        Performance: false,
        PerformanceEntry: false,
        PerformanceMark: false,
        PerformanceMeasure: false,
        PerformanceNavigation: false,
        PerformanceResourceTiming: false,
        PerformanceTiming: false,
        postMessage: true,
        Promise: false,
        queueMicrotask: false,
        registration: false,
        removeEventListener: false,
        Request: false,
        Response: false,
        self: false,
        ServiceWorker: false,
        ServiceWorkerContainer: false,
        ServiceWorkerGlobalScope: false,
        ServiceWorkerMessageEvent: false,
        ServiceWorkerRegistration: false,
        setInterval: false,
        setTimeout: false,
        skipWaiting: false,
        TextDecoder: false,
        TextEncoder: false,
        URL: false,
        URLSearchParams: false,
        WebSocket: false,
        WindowClient: false,
        Worker: false,
        WorkerGlobalScope: false,
        XMLHttpRequest: false
      },
      atomtest: {
        advanceClock: false,
        fakeClearInterval: false,
        fakeClearTimeout: false,
        fakeSetInterval: false,
        fakeSetTimeout: false,
        resetTimeouts: false,
        waitsForPromise: false
      },
      embertest: {
        andThen: false,
        click: false,
        currentPath: false,
        currentRouteName: false,
        currentURL: false,
        fillIn: false,
        find: false,
        findAll: false,
        findWithAssert: false,
        keyEvent: false,
        pauseTest: false,
        resumeTest: false,
        triggerEvent: false,
        visit: false,
        wait: false
      },
      protractor: {
        $: false,
        $$: false,
        browser: false,
        by: false,
        By: false,
        DartObject: false,
        element: false,
        protractor: false
      },
      "shared-node-browser": {
        clearInterval: false,
        clearTimeout: false,
        console: false,
        setInterval: false,
        setTimeout: false,
        URL: false,
        URLSearchParams: false
      },
      webextensions: {
        browser: false,
        chrome: false,
        opr: false
      },
      greasemonkey: {
        cloneInto: false,
        createObjectIn: false,
        exportFunction: false,
        GM: false,
        GM_addStyle: false,
        GM_deleteValue: false,
        GM_getResourceText: false,
        GM_getResourceURL: false,
        GM_getValue: false,
        GM_info: false,
        GM_listValues: false,
        GM_log: false,
        GM_openInTab: false,
        GM_registerMenuCommand: false,
        GM_setClipboard: false,
        GM_setValue: false,
        GM_xmlhttpRequest: false,
        unsafeWindow: false
      },
      devtools: {
        $: false,
        $_: false,
        $$: false,
        $0: false,
        $1: false,
        $2: false,
        $3: false,
        $4: false,
        $x: false,
        chrome: false,
        clear: false,
        copy: false,
        debug: false,
        dir: false,
        dirxml: false,
        getEventListeners: false,
        inspect: false,
        keys: false,
        monitor: false,
        monitorEvents: false,
        profile: false,
        profileEnd: false,
        queryObjects: false,
        table: false,
        undebug: false,
        unmonitor: false,
        unmonitorEvents: false,
        values: false
      }
    };
  }
});

// node_modules/globals/index.js
var require_globals2 = __commonJS({
  "node_modules/globals/index.js"(exports, module2) {
    "use strict";
    module2.exports = require_globals();
  }
});

// node_modules/@babel/traverse/lib/scope/index.js
var require_scope = __commonJS({
  "node_modules/@babel/traverse/lib/scope/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _renamer = require_renamer();
    var _index = require_lib13();
    var _binding = require_binding();
    var _globals = require_globals2();
    var _t = require_lib3();
    var _cache = require_cache();
    var {
      NOT_LOCAL_BINDING,
      callExpression,
      cloneNode,
      getBindingIdentifiers,
      identifier,
      isArrayExpression,
      isBinary,
      isClass,
      isClassBody,
      isClassDeclaration,
      isExportAllDeclaration,
      isExportDefaultDeclaration,
      isExportNamedDeclaration: isExportNamedDeclaration2,
      isFunctionDeclaration,
      isIdentifier: isIdentifier3,
      isImportDeclaration,
      isLiteral,
      isMethod,
      isModuleSpecifier,
      isNullLiteral,
      isObjectExpression: isObjectExpression2,
      isProperty,
      isPureish,
      isRegExpLiteral,
      isSuper,
      isTaggedTemplateExpression,
      isTemplateLiteral,
      isThisExpression,
      isUnaryExpression,
      isVariableDeclaration: isVariableDeclaration2,
      matchesPattern,
      memberExpression,
      numericLiteral,
      toIdentifier: toIdentifier2,
      unaryExpression,
      variableDeclaration,
      variableDeclarator,
      isRecordExpression,
      isTupleExpression,
      isObjectProperty,
      isTopicReference,
      isMetaProperty,
      isPrivateName,
      isExportDeclaration
    } = _t;
    function gatherNodeParts(node2, parts) {
      switch (node2 == null ? void 0 : node2.type) {
        default:
          if (isImportDeclaration(node2) || isExportDeclaration(node2)) {
            if ((isExportAllDeclaration(node2) || isExportNamedDeclaration2(node2) || isImportDeclaration(node2)) && node2.source) {
              gatherNodeParts(node2.source, parts);
            } else if ((isExportNamedDeclaration2(node2) || isImportDeclaration(node2)) && node2.specifiers && node2.specifiers.length) {
              for (const e of node2.specifiers)
                gatherNodeParts(e, parts);
            } else if ((isExportDefaultDeclaration(node2) || isExportNamedDeclaration2(node2)) && node2.declaration) {
              gatherNodeParts(node2.declaration, parts);
            }
          } else if (isModuleSpecifier(node2)) {
            gatherNodeParts(node2.local, parts);
          } else if (isLiteral(node2) && !isNullLiteral(node2) && !isRegExpLiteral(node2) && !isTemplateLiteral(node2)) {
            parts.push(node2.value);
          }
          break;
        case "MemberExpression":
        case "OptionalMemberExpression":
        case "JSXMemberExpression":
          gatherNodeParts(node2.object, parts);
          gatherNodeParts(node2.property, parts);
          break;
        case "Identifier":
        case "JSXIdentifier":
          parts.push(node2.name);
          break;
        case "CallExpression":
        case "OptionalCallExpression":
        case "NewExpression":
          gatherNodeParts(node2.callee, parts);
          break;
        case "ObjectExpression":
        case "ObjectPattern":
          for (const e of node2.properties) {
            gatherNodeParts(e, parts);
          }
          break;
        case "SpreadElement":
        case "RestElement":
          gatherNodeParts(node2.argument, parts);
          break;
        case "ObjectProperty":
        case "ObjectMethod":
        case "ClassProperty":
        case "ClassMethod":
        case "ClassPrivateProperty":
        case "ClassPrivateMethod":
          gatherNodeParts(node2.key, parts);
          break;
        case "ThisExpression":
          parts.push("this");
          break;
        case "Super":
          parts.push("super");
          break;
        case "Import":
          parts.push("import");
          break;
        case "DoExpression":
          parts.push("do");
          break;
        case "YieldExpression":
          parts.push("yield");
          gatherNodeParts(node2.argument, parts);
          break;
        case "AwaitExpression":
          parts.push("await");
          gatherNodeParts(node2.argument, parts);
          break;
        case "AssignmentExpression":
          gatherNodeParts(node2.left, parts);
          break;
        case "VariableDeclarator":
          gatherNodeParts(node2.id, parts);
          break;
        case "FunctionExpression":
        case "FunctionDeclaration":
        case "ClassExpression":
        case "ClassDeclaration":
          gatherNodeParts(node2.id, parts);
          break;
        case "PrivateName":
          gatherNodeParts(node2.id, parts);
          break;
        case "ParenthesizedExpression":
          gatherNodeParts(node2.expression, parts);
          break;
        case "UnaryExpression":
        case "UpdateExpression":
          gatherNodeParts(node2.argument, parts);
          break;
        case "MetaProperty":
          gatherNodeParts(node2.meta, parts);
          gatherNodeParts(node2.property, parts);
          break;
        case "JSXElement":
          gatherNodeParts(node2.openingElement, parts);
          break;
        case "JSXOpeningElement":
          gatherNodeParts(node2.name, parts);
          break;
        case "JSXFragment":
          gatherNodeParts(node2.openingFragment, parts);
          break;
        case "JSXOpeningFragment":
          parts.push("Fragment");
          break;
        case "JSXNamespacedName":
          gatherNodeParts(node2.namespace, parts);
          gatherNodeParts(node2.name, parts);
          break;
      }
    }
    var collectorVisitor = {
      ForStatement(path) {
        const declar = path.get("init");
        if (declar.isVar()) {
          const {
            scope
          } = path;
          const parentScope = scope.getFunctionParent() || scope.getProgramParent();
          parentScope.registerBinding("var", declar);
        }
      },
      Declaration(path) {
        if (path.isBlockScoped())
          return;
        if (path.isImportDeclaration())
          return;
        if (path.isExportDeclaration())
          return;
        const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
        parent.registerDeclaration(path);
      },
      ImportDeclaration(path) {
        const parent = path.scope.getBlockParent();
        parent.registerDeclaration(path);
      },
      ReferencedIdentifier(path, state) {
        state.references.push(path);
      },
      ForXStatement(path, state) {
        const left = path.get("left");
        if (left.isPattern() || left.isIdentifier()) {
          state.constantViolations.push(path);
        } else if (left.isVar()) {
          const {
            scope
          } = path;
          const parentScope = scope.getFunctionParent() || scope.getProgramParent();
          parentScope.registerBinding("var", left);
        }
      },
      ExportDeclaration: {
        exit(path) {
          const {
            node: node2,
            scope
          } = path;
          if (isExportAllDeclaration(node2))
            return;
          const declar = node2.declaration;
          if (isClassDeclaration(declar) || isFunctionDeclaration(declar)) {
            const id = declar.id;
            if (!id)
              return;
            const binding = scope.getBinding(id.name);
            binding == null ? void 0 : binding.reference(path);
          } else if (isVariableDeclaration2(declar)) {
            for (const decl of declar.declarations) {
              for (const name2 of Object.keys(getBindingIdentifiers(decl))) {
                const binding = scope.getBinding(name2);
                binding == null ? void 0 : binding.reference(path);
              }
            }
          }
        }
      },
      LabeledStatement(path) {
        path.scope.getBlockParent().registerDeclaration(path);
      },
      AssignmentExpression(path, state) {
        state.assignments.push(path);
      },
      UpdateExpression(path, state) {
        state.constantViolations.push(path);
      },
      UnaryExpression(path, state) {
        if (path.node.operator === "delete") {
          state.constantViolations.push(path);
        }
      },
      BlockScoped(path) {
        let scope = path.scope;
        if (scope.path === path)
          scope = scope.parent;
        const parent = scope.getBlockParent();
        parent.registerDeclaration(path);
        if (path.isClassDeclaration() && path.node.id) {
          const id = path.node.id;
          const name2 = id.name;
          path.scope.bindings[name2] = path.scope.parent.getBinding(name2);
        }
      },
      CatchClause(path) {
        path.scope.registerBinding("let", path);
      },
      Function(path) {
        const params = path.get("params");
        for (const param of params) {
          path.scope.registerBinding("param", param);
        }
        if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
          path.scope.registerBinding("local", path.get("id"), path);
        }
      },
      ClassExpression(path) {
        if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
          path.scope.registerBinding("local", path);
        }
      }
    };
    var uid = 0;
    var Scope6 = class {
      constructor(path) {
        this.uid = void 0;
        this.path = void 0;
        this.block = void 0;
        this.labels = void 0;
        this.inited = void 0;
        this.bindings = void 0;
        this.references = void 0;
        this.globals = void 0;
        this.uids = void 0;
        this.data = void 0;
        this.crawling = void 0;
        const {
          node: node2
        } = path;
        const cached = _cache.scope.get(node2);
        if ((cached == null ? void 0 : cached.path) === path) {
          return cached;
        }
        _cache.scope.set(node2, this);
        this.uid = uid++;
        this.block = node2;
        this.path = path;
        this.labels = /* @__PURE__ */ new Map();
        this.inited = false;
      }
      get parent() {
        var _parent;
        let parent, path = this.path;
        do {
          const shouldSkip = path.key === "key" || path.listKey === "decorators";
          path = path.parentPath;
          if (shouldSkip && path.isMethod())
            path = path.parentPath;
          if (path && path.isScope())
            parent = path;
        } while (path && !parent);
        return (_parent = parent) == null ? void 0 : _parent.scope;
      }
      get parentBlock() {
        return this.path.parent;
      }
      get hub() {
        return this.path.hub;
      }
      traverse(node2, opts, state) {
        (0, _index.default)(node2, opts, this, state, this.path);
      }
      generateDeclaredUidIdentifier(name2) {
        const id = this.generateUidIdentifier(name2);
        this.push({
          id
        });
        return cloneNode(id);
      }
      generateUidIdentifier(name2) {
        return identifier(this.generateUid(name2));
      }
      generateUid(name2 = "temp") {
        name2 = toIdentifier2(name2).replace(/^_+/, "").replace(/[0-9]+$/g, "");
        let uid2;
        let i = 1;
        do {
          uid2 = this._generateUid(name2, i);
          i++;
        } while (this.hasLabel(uid2) || this.hasBinding(uid2) || this.hasGlobal(uid2) || this.hasReference(uid2));
        const program = this.getProgramParent();
        program.references[uid2] = true;
        program.uids[uid2] = true;
        return uid2;
      }
      _generateUid(name2, i) {
        let id = name2;
        if (i > 1)
          id += i;
        return `_${id}`;
      }
      generateUidBasedOnNode(node2, defaultName) {
        const parts = [];
        gatherNodeParts(node2, parts);
        let id = parts.join("$");
        id = id.replace(/^_/, "") || defaultName || "ref";
        return this.generateUid(id.slice(0, 20));
      }
      generateUidIdentifierBasedOnNode(node2, defaultName) {
        return identifier(this.generateUidBasedOnNode(node2, defaultName));
      }
      isStatic(node2) {
        if (isThisExpression(node2) || isSuper(node2) || isTopicReference(node2)) {
          return true;
        }
        if (isIdentifier3(node2)) {
          const binding = this.getBinding(node2.name);
          if (binding) {
            return binding.constant;
          } else {
            return this.hasBinding(node2.name);
          }
        }
        return false;
      }
      maybeGenerateMemoised(node2, dontPush) {
        if (this.isStatic(node2)) {
          return null;
        } else {
          const id = this.generateUidIdentifierBasedOnNode(node2);
          if (!dontPush) {
            this.push({
              id
            });
            return cloneNode(id);
          }
          return id;
        }
      }
      checkBlockScopedCollisions(local, kind, name2, id) {
        if (kind === "param")
          return;
        if (local.kind === "local")
          return;
        const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && kind === "const";
        if (duplicate) {
          throw this.hub.buildError(id, `Duplicate declaration "${name2}"`, TypeError);
        }
      }
      rename(oldName, newName) {
        const binding = this.getBinding(oldName);
        if (binding) {
          newName || (newName = this.generateUidIdentifier(oldName).name);
          const renamer = new _renamer.default(binding, oldName, newName);
          {
            renamer.rename(arguments[2]);
          }
        }
      }
      _renameFromMap(map, oldName, newName, value2) {
        if (map[oldName]) {
          map[newName] = value2;
          map[oldName] = null;
        }
      }
      dump() {
        const sep = "-".repeat(60);
        console.log(sep);
        let scope = this;
        do {
          console.log("#", scope.block.type);
          for (const name2 of Object.keys(scope.bindings)) {
            const binding = scope.bindings[name2];
            console.log(" -", name2, {
              constant: binding.constant,
              references: binding.references,
              violations: binding.constantViolations.length,
              kind: binding.kind
            });
          }
        } while (scope = scope.parent);
        console.log(sep);
      }
      toArray(node2, i, arrayLikeIsIterable) {
        if (isIdentifier3(node2)) {
          const binding = this.getBinding(node2.name);
          if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
            return node2;
          }
        }
        if (isArrayExpression(node2)) {
          return node2;
        }
        if (isIdentifier3(node2, {
          name: "arguments"
        })) {
          return callExpression(memberExpression(memberExpression(memberExpression(identifier("Array"), identifier("prototype")), identifier("slice")), identifier("call")), [node2]);
        }
        let helperName;
        const args = [node2];
        if (i === true) {
          helperName = "toConsumableArray";
        } else if (typeof i === "number") {
          args.push(numericLiteral(i));
          helperName = "slicedToArray";
        } else {
          helperName = "toArray";
        }
        if (arrayLikeIsIterable) {
          args.unshift(this.hub.addHelper(helperName));
          helperName = "maybeArrayLike";
        }
        return callExpression(this.hub.addHelper(helperName), args);
      }
      hasLabel(name2) {
        return !!this.getLabel(name2);
      }
      getLabel(name2) {
        return this.labels.get(name2);
      }
      registerLabel(path) {
        this.labels.set(path.node.label.name, path);
      }
      registerDeclaration(path) {
        if (path.isLabeledStatement()) {
          this.registerLabel(path);
        } else if (path.isFunctionDeclaration()) {
          this.registerBinding("hoisted", path.get("id"), path);
        } else if (path.isVariableDeclaration()) {
          const declarations = path.get("declarations");
          const {
            kind
          } = path.node;
          for (const declar of declarations) {
            this.registerBinding(kind === "using" ? "const" : kind, declar);
          }
        } else if (path.isClassDeclaration()) {
          if (path.node.declare)
            return;
          this.registerBinding("let", path);
        } else if (path.isImportDeclaration()) {
          const isTypeDeclaration = path.node.importKind === "type" || path.node.importKind === "typeof";
          const specifiers = path.get("specifiers");
          for (const specifier of specifiers) {
            const isTypeSpecifier = isTypeDeclaration || specifier.isImportSpecifier() && (specifier.node.importKind === "type" || specifier.node.importKind === "typeof");
            this.registerBinding(isTypeSpecifier ? "unknown" : "module", specifier);
          }
        } else if (path.isExportDeclaration()) {
          const declar = path.get("declaration");
          if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) {
            this.registerDeclaration(declar);
          }
        } else {
          this.registerBinding("unknown", path);
        }
      }
      buildUndefinedNode() {
        return unaryExpression("void", numericLiteral(0), true);
      }
      registerConstantViolation(path) {
        const ids = path.getBindingIdentifiers();
        for (const name2 of Object.keys(ids)) {
          const binding = this.getBinding(name2);
          if (binding)
            binding.reassign(path);
        }
      }
      registerBinding(kind, path, bindingPath = path) {
        if (!kind)
          throw new ReferenceError("no `kind`");
        if (path.isVariableDeclaration()) {
          const declarators = path.get("declarations");
          for (const declar of declarators) {
            this.registerBinding(kind, declar);
          }
          return;
        }
        const parent = this.getProgramParent();
        const ids = path.getOuterBindingIdentifiers(true);
        for (const name2 of Object.keys(ids)) {
          parent.references[name2] = true;
          for (const id of ids[name2]) {
            const local = this.getOwnBinding(name2);
            if (local) {
              if (local.identifier === id)
                continue;
              this.checkBlockScopedCollisions(local, kind, name2, id);
            }
            if (local) {
              this.registerConstantViolation(bindingPath);
            } else {
              this.bindings[name2] = new _binding.default({
                identifier: id,
                scope: this,
                path: bindingPath,
                kind
              });
            }
          }
        }
      }
      addGlobal(node2) {
        this.globals[node2.name] = node2;
      }
      hasUid(name2) {
        let scope = this;
        do {
          if (scope.uids[name2])
            return true;
        } while (scope = scope.parent);
        return false;
      }
      hasGlobal(name2) {
        let scope = this;
        do {
          if (scope.globals[name2])
            return true;
        } while (scope = scope.parent);
        return false;
      }
      hasReference(name2) {
        return !!this.getProgramParent().references[name2];
      }
      isPure(node2, constantsOnly) {
        if (isIdentifier3(node2)) {
          const binding = this.getBinding(node2.name);
          if (!binding)
            return false;
          if (constantsOnly)
            return binding.constant;
          return true;
        } else if (isThisExpression(node2) || isMetaProperty(node2) || isTopicReference(node2) || isPrivateName(node2)) {
          return true;
        } else if (isClass(node2)) {
          var _node$decorators;
          if (node2.superClass && !this.isPure(node2.superClass, constantsOnly)) {
            return false;
          }
          if (((_node$decorators = node2.decorators) == null ? void 0 : _node$decorators.length) > 0) {
            return false;
          }
          return this.isPure(node2.body, constantsOnly);
        } else if (isClassBody(node2)) {
          for (const method of node2.body) {
            if (!this.isPure(method, constantsOnly))
              return false;
          }
          return true;
        } else if (isBinary(node2)) {
          return this.isPure(node2.left, constantsOnly) && this.isPure(node2.right, constantsOnly);
        } else if (isArrayExpression(node2) || isTupleExpression(node2)) {
          for (const elem of node2.elements) {
            if (elem !== null && !this.isPure(elem, constantsOnly))
              return false;
          }
          return true;
        } else if (isObjectExpression2(node2) || isRecordExpression(node2)) {
          for (const prop of node2.properties) {
            if (!this.isPure(prop, constantsOnly))
              return false;
          }
          return true;
        } else if (isMethod(node2)) {
          var _node$decorators2;
          if (node2.computed && !this.isPure(node2.key, constantsOnly))
            return false;
          if (((_node$decorators2 = node2.decorators) == null ? void 0 : _node$decorators2.length) > 0) {
            return false;
          }
          return true;
        } else if (isProperty(node2)) {
          var _node$decorators3;
          if (node2.computed && !this.isPure(node2.key, constantsOnly))
            return false;
          if (((_node$decorators3 = node2.decorators) == null ? void 0 : _node$decorators3.length) > 0) {
            return false;
          }
          if (isObjectProperty(node2) || node2.static) {
            if (node2.value !== null && !this.isPure(node2.value, constantsOnly)) {
              return false;
            }
          }
          return true;
        } else if (isUnaryExpression(node2)) {
          return this.isPure(node2.argument, constantsOnly);
        } else if (isTaggedTemplateExpression(node2)) {
          return matchesPattern(node2.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node2.quasi, constantsOnly);
        } else if (isTemplateLiteral(node2)) {
          for (const expression of node2.expressions) {
            if (!this.isPure(expression, constantsOnly))
              return false;
          }
          return true;
        } else {
          return isPureish(node2);
        }
      }
      setData(key2, val) {
        return this.data[key2] = val;
      }
      getData(key2) {
        let scope = this;
        do {
          const data3 = scope.data[key2];
          if (data3 != null)
            return data3;
        } while (scope = scope.parent);
      }
      removeData(key2) {
        let scope = this;
        do {
          const data3 = scope.data[key2];
          if (data3 != null)
            scope.data[key2] = null;
        } while (scope = scope.parent);
      }
      init() {
        if (!this.inited) {
          this.inited = true;
          this.crawl();
        }
      }
      crawl() {
        const path = this.path;
        this.references = /* @__PURE__ */ Object.create(null);
        this.bindings = /* @__PURE__ */ Object.create(null);
        this.globals = /* @__PURE__ */ Object.create(null);
        this.uids = /* @__PURE__ */ Object.create(null);
        this.data = /* @__PURE__ */ Object.create(null);
        const programParent = this.getProgramParent();
        if (programParent.crawling)
          return;
        const state = {
          references: [],
          constantViolations: [],
          assignments: []
        };
        this.crawling = true;
        if (path.type !== "Program" && collectorVisitor._exploded) {
          for (const visit3 of collectorVisitor.enter) {
            visit3(path, state);
          }
          const typeVisitors = collectorVisitor[path.type];
          if (typeVisitors) {
            for (const visit3 of typeVisitors.enter) {
              visit3(path, state);
            }
          }
        }
        path.traverse(collectorVisitor, state);
        this.crawling = false;
        for (const path2 of state.assignments) {
          const ids = path2.getBindingIdentifiers();
          for (const name2 of Object.keys(ids)) {
            if (path2.scope.getBinding(name2))
              continue;
            programParent.addGlobal(ids[name2]);
          }
          path2.scope.registerConstantViolation(path2);
        }
        for (const ref3 of state.references) {
          const binding = ref3.scope.getBinding(ref3.node.name);
          if (binding) {
            binding.reference(ref3);
          } else {
            programParent.addGlobal(ref3.node);
          }
        }
        for (const path2 of state.constantViolations) {
          path2.scope.registerConstantViolation(path2);
        }
      }
      push(opts) {
        let path = this.path;
        if (path.isPattern()) {
          path = this.getPatternParent().path;
        } else if (!path.isBlockStatement() && !path.isProgram()) {
          path = this.getBlockParent().path;
        }
        if (path.isSwitchStatement()) {
          path = (this.getFunctionParent() || this.getProgramParent()).path;
        }
        if (path.isLoop() || path.isCatchClause() || path.isFunction()) {
          path.ensureBlock();
          path = path.get("body");
        }
        const unique = opts.unique;
        const kind = opts.kind || "var";
        const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
        const dataKey = `declaration:${kind}:${blockHoist}`;
        let declarPath = !unique && path.getData(dataKey);
        if (!declarPath) {
          const declar = variableDeclaration(kind, []);
          declar._blockHoist = blockHoist;
          [declarPath] = path.unshiftContainer("body", [declar]);
          if (!unique)
            path.setData(dataKey, declarPath);
        }
        const declarator = variableDeclarator(opts.id, opts.init);
        const len = declarPath.node.declarations.push(declarator);
        path.scope.registerBinding(kind, declarPath.get("declarations")[len - 1]);
      }
      getProgramParent() {
        let scope = this;
        do {
          if (scope.path.isProgram()) {
            return scope;
          }
        } while (scope = scope.parent);
        throw new Error("Couldn't find a Program");
      }
      getFunctionParent() {
        let scope = this;
        do {
          if (scope.path.isFunctionParent()) {
            return scope;
          }
        } while (scope = scope.parent);
        return null;
      }
      getBlockParent() {
        let scope = this;
        do {
          if (scope.path.isBlockParent()) {
            return scope;
          }
        } while (scope = scope.parent);
        throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
      }
      getPatternParent() {
        let scope = this;
        do {
          if (!scope.path.isPattern()) {
            return scope.getBlockParent();
          }
        } while (scope = scope.parent.parent);
        throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
      }
      getAllBindings() {
        const ids = /* @__PURE__ */ Object.create(null);
        let scope = this;
        do {
          for (const key2 of Object.keys(scope.bindings)) {
            if (key2 in ids === false) {
              ids[key2] = scope.bindings[key2];
            }
          }
          scope = scope.parent;
        } while (scope);
        return ids;
      }
      getAllBindingsOfKind(...kinds) {
        const ids = /* @__PURE__ */ Object.create(null);
        for (const kind of kinds) {
          let scope = this;
          do {
            for (const name2 of Object.keys(scope.bindings)) {
              const binding = scope.bindings[name2];
              if (binding.kind === kind)
                ids[name2] = binding;
            }
            scope = scope.parent;
          } while (scope);
        }
        return ids;
      }
      bindingIdentifierEquals(name2, node2) {
        return this.getBindingIdentifier(name2) === node2;
      }
      getBinding(name2) {
        let scope = this;
        let previousPath;
        do {
          const binding = scope.getOwnBinding(name2);
          if (binding) {
            var _previousPath;
            if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param" && binding.kind !== "local") {
            } else {
              return binding;
            }
          } else if (!binding && name2 === "arguments" && scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
            break;
          }
          previousPath = scope.path;
        } while (scope = scope.parent);
      }
      getOwnBinding(name2) {
        return this.bindings[name2];
      }
      getBindingIdentifier(name2) {
        var _this$getBinding;
        return (_this$getBinding = this.getBinding(name2)) == null ? void 0 : _this$getBinding.identifier;
      }
      getOwnBindingIdentifier(name2) {
        const binding = this.bindings[name2];
        return binding == null ? void 0 : binding.identifier;
      }
      hasOwnBinding(name2) {
        return !!this.getOwnBinding(name2);
      }
      hasBinding(name2, opts) {
        var _opts, _opts2, _opts3;
        if (!name2)
          return false;
        if (this.hasOwnBinding(name2))
          return true;
        {
          if (typeof opts === "boolean")
            opts = {
              noGlobals: opts
            };
        }
        if (this.parentHasBinding(name2, opts))
          return true;
        if (!((_opts = opts) != null && _opts.noUids) && this.hasUid(name2))
          return true;
        if (!((_opts2 = opts) != null && _opts2.noGlobals) && Scope6.globals.includes(name2))
          return true;
        if (!((_opts3 = opts) != null && _opts3.noGlobals) && Scope6.contextVariables.includes(name2))
          return true;
        return false;
      }
      parentHasBinding(name2, opts) {
        var _this$parent;
        return (_this$parent = this.parent) == null ? void 0 : _this$parent.hasBinding(name2, opts);
      }
      moveBindingTo(name2, scope) {
        const info = this.getBinding(name2);
        if (info) {
          info.scope.removeOwnBinding(name2);
          info.scope = scope;
          scope.bindings[name2] = info;
        }
      }
      removeOwnBinding(name2) {
        delete this.bindings[name2];
      }
      removeBinding(name2) {
        var _this$getBinding2;
        (_this$getBinding2 = this.getBinding(name2)) == null ? void 0 : _this$getBinding2.scope.removeOwnBinding(name2);
        let scope = this;
        do {
          if (scope.uids[name2]) {
            scope.uids[name2] = false;
          }
        } while (scope = scope.parent);
      }
    };
    exports.default = Scope6;
    Scope6.globals = Object.keys(_globals.builtin);
    Scope6.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];
  }
});

// node_modules/@babel/traverse/lib/path/ancestry.js
var require_ancestry = __commonJS({
  "node_modules/@babel/traverse/lib/path/ancestry.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.find = find2;
    exports.findParent = findParent;
    exports.getAncestry = getAncestry;
    exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
    exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
    exports.getFunctionParent = getFunctionParent;
    exports.getStatementParent = getStatementParent;
    exports.inType = inType;
    exports.isAncestor = isAncestor;
    exports.isDescendant = isDescendant;
    var _t = require_lib3();
    var {
      VISITOR_KEYS
    } = _t;
    function findParent(callback) {
      let path = this;
      while (path = path.parentPath) {
        if (callback(path))
          return path;
      }
      return null;
    }
    function find2(callback) {
      let path = this;
      do {
        if (callback(path))
          return path;
      } while (path = path.parentPath);
      return null;
    }
    function getFunctionParent() {
      return this.findParent((p) => p.isFunction());
    }
    function getStatementParent() {
      let path = this;
      do {
        if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
          break;
        } else {
          path = path.parentPath;
        }
      } while (path);
      if (path && (path.isProgram() || path.isFile())) {
        throw new Error("File/Program node, we can't possibly find a statement parent to this");
      }
      return path;
    }
    function getEarliestCommonAncestorFrom(paths) {
      return this.getDeepestCommonAncestorFrom(paths, function(deepest, i, ancestries) {
        let earliest;
        const keys2 = VISITOR_KEYS[deepest.type];
        for (const ancestry of ancestries) {
          const path = ancestry[i + 1];
          if (!earliest) {
            earliest = path;
            continue;
          }
          if (path.listKey && earliest.listKey === path.listKey) {
            if (path.key < earliest.key) {
              earliest = path;
              continue;
            }
          }
          const earliestKeyIndex = keys2.indexOf(earliest.parentKey);
          const currentKeyIndex = keys2.indexOf(path.parentKey);
          if (earliestKeyIndex > currentKeyIndex) {
            earliest = path;
          }
        }
        return earliest;
      });
    }
    function getDeepestCommonAncestorFrom(paths, filter) {
      if (!paths.length) {
        return this;
      }
      if (paths.length === 1) {
        return paths[0];
      }
      let minDepth = Infinity;
      let lastCommonIndex, lastCommon;
      const ancestries = paths.map((path) => {
        const ancestry = [];
        do {
          ancestry.unshift(path);
        } while ((path = path.parentPath) && path !== this);
        if (ancestry.length < minDepth) {
          minDepth = ancestry.length;
        }
        return ancestry;
      });
      const first = ancestries[0];
      depthLoop:
        for (let i = 0; i < minDepth; i++) {
          const shouldMatch = first[i];
          for (const ancestry of ancestries) {
            if (ancestry[i] !== shouldMatch) {
              break depthLoop;
            }
          }
          lastCommonIndex = i;
          lastCommon = shouldMatch;
        }
      if (lastCommon) {
        if (filter) {
          return filter(lastCommon, lastCommonIndex, ancestries);
        } else {
          return lastCommon;
        }
      } else {
        throw new Error("Couldn't find intersection");
      }
    }
    function getAncestry() {
      let path = this;
      const paths = [];
      do {
        paths.push(path);
      } while (path = path.parentPath);
      return paths;
    }
    function isAncestor(maybeDescendant) {
      return maybeDescendant.isDescendant(this);
    }
    function isDescendant(maybeAncestor) {
      return !!this.findParent((parent) => parent === maybeAncestor);
    }
    function inType(...candidateTypes) {
      let path = this;
      while (path) {
        for (const type of candidateTypes) {
          if (path.node.type === type)
            return true;
        }
        path = path.parentPath;
      }
      return false;
    }
  }
});

// node_modules/@babel/traverse/lib/path/inference/util.js
var require_util = __commonJS({
  "node_modules/@babel/traverse/lib/path/inference/util.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.createUnionType = createUnionType;
    var _t = require_lib3();
    var {
      createFlowUnionType,
      createTSUnionType,
      createUnionTypeAnnotation,
      isFlowType,
      isTSType
    } = _t;
    function createUnionType(types3) {
      {
        if (isFlowType(types3[0])) {
          if (createFlowUnionType) {
            return createFlowUnionType(types3);
          }
          return createUnionTypeAnnotation(types3);
        } else {
          if (createTSUnionType) {
            return createTSUnionType(types3);
          }
        }
      }
    }
  }
});

// node_modules/@babel/traverse/lib/path/inference/inferer-reference.js
var require_inferer_reference = __commonJS({
  "node_modules/@babel/traverse/lib/path/inference/inferer-reference.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = _default;
    var _t = require_lib3();
    var _util = require_util();
    var {
      BOOLEAN_NUMBER_BINARY_OPERATORS,
      createTypeAnnotationBasedOnTypeof,
      numberTypeAnnotation,
      voidTypeAnnotation
    } = _t;
    function _default(node2) {
      if (!this.isReferenced())
        return;
      const binding = this.scope.getBinding(node2.name);
      if (binding) {
        if (binding.identifier.typeAnnotation) {
          return binding.identifier.typeAnnotation;
        } else {
          return getTypeAnnotationBindingConstantViolations(binding, this, node2.name);
        }
      }
      if (node2.name === "undefined") {
        return voidTypeAnnotation();
      } else if (node2.name === "NaN" || node2.name === "Infinity") {
        return numberTypeAnnotation();
      } else if (node2.name === "arguments") {
      }
    }
    function getTypeAnnotationBindingConstantViolations(binding, path, name2) {
      const types3 = [];
      const functionConstantViolations = [];
      let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
      const testType = getConditionalAnnotation(binding, path, name2);
      if (testType) {
        const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
        constantViolations = constantViolations.filter((path2) => testConstantViolations.indexOf(path2) < 0);
        types3.push(testType.typeAnnotation);
      }
      if (constantViolations.length) {
        constantViolations.push(...functionConstantViolations);
        for (const violation of constantViolations) {
          types3.push(violation.getTypeAnnotation());
        }
      }
      if (!types3.length) {
        return;
      }
      return (0, _util.createUnionType)(types3);
    }
    function getConstantViolationsBefore(binding, path, functions) {
      const violations = binding.constantViolations.slice();
      violations.unshift(binding.path);
      return violations.filter((violation) => {
        violation = violation.resolve();
        const status = violation._guessExecutionStatusRelativeTo(path);
        if (functions && status === "unknown")
          functions.push(violation);
        return status === "before";
      });
    }
    function inferAnnotationFromBinaryExpression(name2, path) {
      const operator = path.node.operator;
      const right = path.get("right").resolve();
      const left = path.get("left").resolve();
      let target;
      if (left.isIdentifier({
        name: name2
      })) {
        target = right;
      } else if (right.isIdentifier({
        name: name2
      })) {
        target = left;
      }
      if (target) {
        if (operator === "===") {
          return target.getTypeAnnotation();
        }
        if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
          return numberTypeAnnotation();
        }
        return;
      }
      if (operator !== "===" && operator !== "==")
        return;
      let typeofPath;
      let typePath;
      if (left.isUnaryExpression({
        operator: "typeof"
      })) {
        typeofPath = left;
        typePath = right;
      } else if (right.isUnaryExpression({
        operator: "typeof"
      })) {
        typeofPath = right;
        typePath = left;
      }
      if (!typeofPath)
        return;
      if (!typeofPath.get("argument").isIdentifier({
        name: name2
      }))
        return;
      typePath = typePath.resolve();
      if (!typePath.isLiteral())
        return;
      const typeValue = typePath.node.value;
      if (typeof typeValue !== "string")
        return;
      return createTypeAnnotationBasedOnTypeof(typeValue);
    }
    function getParentConditionalPath(binding, path, name2) {
      let parentPath;
      while (parentPath = path.parentPath) {
        if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
          if (path.key === "test") {
            return;
          }
          return parentPath;
        }
        if (parentPath.isFunction()) {
          if (parentPath.parentPath.scope.getBinding(name2) !== binding)
            return;
        }
        path = parentPath;
      }
    }
    function getConditionalAnnotation(binding, path, name2) {
      const ifStatement = getParentConditionalPath(binding, path, name2);
      if (!ifStatement)
        return;
      const test = ifStatement.get("test");
      const paths = [test];
      const types3 = [];
      for (let i = 0; i < paths.length; i++) {
        const path2 = paths[i];
        if (path2.isLogicalExpression()) {
          if (path2.node.operator === "&&") {
            paths.push(path2.get("left"));
            paths.push(path2.get("right"));
          }
        } else if (path2.isBinaryExpression()) {
          const type = inferAnnotationFromBinaryExpression(name2, path2);
          if (type)
            types3.push(type);
        }
      }
      if (types3.length) {
        return {
          typeAnnotation: (0, _util.createUnionType)(types3),
          ifStatement
        };
      }
      return getConditionalAnnotation(binding, ifStatement, name2);
    }
  }
});

// node_modules/@babel/traverse/lib/path/inference/inferers.js
var require_inferers = __commonJS({
  "node_modules/@babel/traverse/lib/path/inference/inferers.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ArrayExpression = ArrayExpression2;
    exports.AssignmentExpression = AssignmentExpression;
    exports.BinaryExpression = BinaryExpression2;
    exports.BooleanLiteral = BooleanLiteral;
    exports.CallExpression = CallExpression;
    exports.ConditionalExpression = ConditionalExpression;
    exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func;
    Object.defineProperty(exports, "Identifier", {
      enumerable: true,
      get: function() {
        return _infererReference.default;
      }
    });
    exports.LogicalExpression = LogicalExpression;
    exports.NewExpression = NewExpression;
    exports.NullLiteral = NullLiteral;
    exports.NumericLiteral = NumericLiteral;
    exports.ObjectExpression = ObjectExpression;
    exports.ParenthesizedExpression = ParenthesizedExpression;
    exports.RegExpLiteral = RegExpLiteral;
    exports.RestElement = RestElement2;
    exports.SequenceExpression = SequenceExpression;
    exports.StringLiteral = StringLiteral;
    exports.TSAsExpression = TSAsExpression;
    exports.TSNonNullExpression = TSNonNullExpression;
    exports.TaggedTemplateExpression = TaggedTemplateExpression;
    exports.TemplateLiteral = TemplateLiteral;
    exports.TypeCastExpression = TypeCastExpression;
    exports.UnaryExpression = UnaryExpression;
    exports.UpdateExpression = UpdateExpression;
    exports.VariableDeclarator = VariableDeclarator;
    var _t = require_lib3();
    var _infererReference = require_inferer_reference();
    var _util = require_util();
    var {
      BOOLEAN_BINARY_OPERATORS,
      BOOLEAN_UNARY_OPERATORS,
      NUMBER_BINARY_OPERATORS,
      NUMBER_UNARY_OPERATORS,
      STRING_UNARY_OPERATORS,
      anyTypeAnnotation,
      arrayTypeAnnotation,
      booleanTypeAnnotation,
      buildMatchMemberExpression,
      genericTypeAnnotation,
      identifier,
      nullLiteralTypeAnnotation,
      numberTypeAnnotation,
      stringTypeAnnotation,
      tupleTypeAnnotation,
      unionTypeAnnotation,
      voidTypeAnnotation,
      isIdentifier: isIdentifier3
    } = _t;
    function VariableDeclarator() {
      if (!this.get("id").isIdentifier())
        return;
      return this.get("init").getTypeAnnotation();
    }
    function TypeCastExpression(node2) {
      return node2.typeAnnotation;
    }
    TypeCastExpression.validParent = true;
    function TSAsExpression(node2) {
      return node2.typeAnnotation;
    }
    TSAsExpression.validParent = true;
    function TSNonNullExpression() {
      return this.get("expression").getTypeAnnotation();
    }
    function NewExpression(node2) {
      if (node2.callee.type === "Identifier") {
        return genericTypeAnnotation(node2.callee);
      }
    }
    function TemplateLiteral() {
      return stringTypeAnnotation();
    }
    function UnaryExpression(node2) {
      const operator = node2.operator;
      if (operator === "void") {
        return voidTypeAnnotation();
      } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
        return numberTypeAnnotation();
      } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
        return stringTypeAnnotation();
      } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
        return booleanTypeAnnotation();
      }
    }
    function BinaryExpression2(node2) {
      const operator = node2.operator;
      if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
        return numberTypeAnnotation();
      } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
        return booleanTypeAnnotation();
      } else if (operator === "+") {
        const right = this.get("right");
        const left = this.get("left");
        if (left.isBaseType("number") && right.isBaseType("number")) {
          return numberTypeAnnotation();
        } else if (left.isBaseType("string") || right.isBaseType("string")) {
          return stringTypeAnnotation();
        }
        return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
      }
    }
    function LogicalExpression() {
      const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
      return (0, _util.createUnionType)(argumentTypes);
    }
    function ConditionalExpression() {
      const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
      return (0, _util.createUnionType)(argumentTypes);
    }
    function SequenceExpression() {
      return this.get("expressions").pop().getTypeAnnotation();
    }
    function ParenthesizedExpression() {
      return this.get("expression").getTypeAnnotation();
    }
    function AssignmentExpression() {
      return this.get("right").getTypeAnnotation();
    }
    function UpdateExpression(node2) {
      const operator = node2.operator;
      if (operator === "++" || operator === "--") {
        return numberTypeAnnotation();
      }
    }
    function StringLiteral() {
      return stringTypeAnnotation();
    }
    function NumericLiteral() {
      return numberTypeAnnotation();
    }
    function BooleanLiteral() {
      return booleanTypeAnnotation();
    }
    function NullLiteral() {
      return nullLiteralTypeAnnotation();
    }
    function RegExpLiteral() {
      return genericTypeAnnotation(identifier("RegExp"));
    }
    function ObjectExpression() {
      return genericTypeAnnotation(identifier("Object"));
    }
    function ArrayExpression2() {
      return genericTypeAnnotation(identifier("Array"));
    }
    function RestElement2() {
      return ArrayExpression2();
    }
    RestElement2.validParent = true;
    function Func() {
      return genericTypeAnnotation(identifier("Function"));
    }
    var isArrayFrom = buildMatchMemberExpression("Array.from");
    var isObjectKeys = buildMatchMemberExpression("Object.keys");
    var isObjectValues = buildMatchMemberExpression("Object.values");
    var isObjectEntries = buildMatchMemberExpression("Object.entries");
    function CallExpression() {
      const {
        callee
      } = this.node;
      if (isObjectKeys(callee)) {
        return arrayTypeAnnotation(stringTypeAnnotation());
      } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier3(callee, {
        name: "Array"
      })) {
        return arrayTypeAnnotation(anyTypeAnnotation());
      } else if (isObjectEntries(callee)) {
        return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
      }
      return resolveCall(this.get("callee"));
    }
    function TaggedTemplateExpression() {
      return resolveCall(this.get("tag"));
    }
    function resolveCall(callee) {
      callee = callee.resolve();
      if (callee.isFunction()) {
        const {
          node: node2
        } = callee;
        if (node2.async) {
          if (node2.generator) {
            return genericTypeAnnotation(identifier("AsyncIterator"));
          } else {
            return genericTypeAnnotation(identifier("Promise"));
          }
        } else {
          if (node2.generator) {
            return genericTypeAnnotation(identifier("Iterator"));
          } else if (callee.node.returnType) {
            return callee.node.returnType;
          } else {
          }
        }
      }
    }
  }
});

// node_modules/@babel/traverse/lib/path/inference/index.js
var require_inference = __commonJS({
  "node_modules/@babel/traverse/lib/path/inference/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._getTypeAnnotation = _getTypeAnnotation;
    exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
    exports.couldBeBaseType = couldBeBaseType;
    exports.getTypeAnnotation = getTypeAnnotation;
    exports.isBaseType = isBaseType;
    exports.isGenericType = isGenericType;
    var inferers = require_inferers();
    var _t = require_lib3();
    var {
      anyTypeAnnotation,
      isAnyTypeAnnotation,
      isArrayTypeAnnotation,
      isBooleanTypeAnnotation,
      isEmptyTypeAnnotation,
      isFlowBaseAnnotation,
      isGenericTypeAnnotation,
      isIdentifier: isIdentifier3,
      isMixedTypeAnnotation,
      isNumberTypeAnnotation,
      isStringTypeAnnotation,
      isTSArrayType,
      isTSTypeAnnotation,
      isTSTypeReference,
      isTupleTypeAnnotation,
      isTypeAnnotation,
      isUnionTypeAnnotation,
      isVoidTypeAnnotation,
      stringTypeAnnotation,
      voidTypeAnnotation
    } = _t;
    function getTypeAnnotation() {
      let type = this.getData("typeAnnotation");
      if (type != null) {
        return type;
      }
      type = this._getTypeAnnotation() || anyTypeAnnotation();
      if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
        type = type.typeAnnotation;
      }
      this.setData("typeAnnotation", type);
      return type;
    }
    var typeAnnotationInferringNodes = /* @__PURE__ */ new WeakSet();
    function _getTypeAnnotation() {
      const node2 = this.node;
      if (!node2) {
        if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
          const declar = this.parentPath.parentPath;
          const declarParent = declar.parentPath;
          if (declar.key === "left" && declarParent.isForInStatement()) {
            return stringTypeAnnotation();
          }
          if (declar.key === "left" && declarParent.isForOfStatement()) {
            return anyTypeAnnotation();
          }
          return voidTypeAnnotation();
        } else {
          return;
        }
      }
      if (node2.typeAnnotation) {
        return node2.typeAnnotation;
      }
      if (typeAnnotationInferringNodes.has(node2)) {
        return;
      }
      typeAnnotationInferringNodes.add(node2);
      try {
        var _inferer;
        let inferer = inferers[node2.type];
        if (inferer) {
          return inferer.call(this, node2);
        }
        inferer = inferers[this.parentPath.type];
        if ((_inferer = inferer) != null && _inferer.validParent) {
          return this.parentPath.getTypeAnnotation();
        }
      } finally {
        typeAnnotationInferringNodes.delete(node2);
      }
    }
    function isBaseType(baseName, soft) {
      return _isBaseType(baseName, this.getTypeAnnotation(), soft);
    }
    function _isBaseType(baseName, type, soft) {
      if (baseName === "string") {
        return isStringTypeAnnotation(type);
      } else if (baseName === "number") {
        return isNumberTypeAnnotation(type);
      } else if (baseName === "boolean") {
        return isBooleanTypeAnnotation(type);
      } else if (baseName === "any") {
        return isAnyTypeAnnotation(type);
      } else if (baseName === "mixed") {
        return isMixedTypeAnnotation(type);
      } else if (baseName === "empty") {
        return isEmptyTypeAnnotation(type);
      } else if (baseName === "void") {
        return isVoidTypeAnnotation(type);
      } else {
        if (soft) {
          return false;
        } else {
          throw new Error(`Unknown base type ${baseName}`);
        }
      }
    }
    function couldBeBaseType(name2) {
      const type = this.getTypeAnnotation();
      if (isAnyTypeAnnotation(type))
        return true;
      if (isUnionTypeAnnotation(type)) {
        for (const type2 of type.types) {
          if (isAnyTypeAnnotation(type2) || _isBaseType(name2, type2, true)) {
            return true;
          }
        }
        return false;
      } else {
        return _isBaseType(name2, type, true);
      }
    }
    function baseTypeStrictlyMatches(rightArg) {
      const left = this.getTypeAnnotation();
      const right = rightArg.getTypeAnnotation();
      if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {
        return right.type === left.type;
      }
      return false;
    }
    function isGenericType(genericName) {
      const type = this.getTypeAnnotation();
      if (genericName === "Array") {
        if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) {
          return true;
        }
      }
      return isGenericTypeAnnotation(type) && isIdentifier3(type.id, {
        name: genericName
      }) || isTSTypeReference(type) && isIdentifier3(type.typeName, {
        name: genericName
      });
    }
  }
});

// node_modules/js-tokens/index.js
var require_js_tokens = __commonJS({
  "node_modules/js-tokens/index.js"(exports) {
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
    exports.matchToToken = function(match) {
      var token2 = { type: "invalid", value: match[0], closed: void 0 };
      if (match[1])
        token2.type = "string", token2.closed = !!(match[3] || match[4]);
      else if (match[5])
        token2.type = "comment";
      else if (match[6])
        token2.type = "comment", token2.closed = !!match[7];
      else if (match[8])
        token2.type = "regex";
      else if (match[9])
        token2.type = "number";
      else if (match[10])
        token2.type = "name";
      else if (match[11])
        token2.type = "punctuator";
      else if (match[12])
        token2.type = "whitespace";
      return token2;
    };
  }
});

// node_modules/escape-string-regexp/index.js
var require_escape_string_regexp = __commonJS({
  "node_modules/escape-string-regexp/index.js"(exports, module2) {
    "use strict";
    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
    module2.exports = function(str) {
      if (typeof str !== "string") {
        throw new TypeError("Expected a string");
      }
      return str.replace(matchOperatorsRe, "\\$&");
    };
  }
});

// node_modules/@babel/highlight/node_modules/color-name/index.js
var require_color_name = __commonJS({
  "node_modules/@babel/highlight/node_modules/color-name/index.js"(exports, module2) {
    "use strict";
    module2.exports = {
      "aliceblue": [240, 248, 255],
      "antiquewhite": [250, 235, 215],
      "aqua": [0, 255, 255],
      "aquamarine": [127, 255, 212],
      "azure": [240, 255, 255],
      "beige": [245, 245, 220],
      "bisque": [255, 228, 196],
      "black": [0, 0, 0],
      "blanchedalmond": [255, 235, 205],
      "blue": [0, 0, 255],
      "blueviolet": [138, 43, 226],
      "brown": [165, 42, 42],
      "burlywood": [222, 184, 135],
      "cadetblue": [95, 158, 160],
      "chartreuse": [127, 255, 0],
      "chocolate": [210, 105, 30],
      "coral": [255, 127, 80],
      "cornflowerblue": [100, 149, 237],
      "cornsilk": [255, 248, 220],
      "crimson": [220, 20, 60],
      "cyan": [0, 255, 255],
      "darkblue": [0, 0, 139],
      "darkcyan": [0, 139, 139],
      "darkgoldenrod": [184, 134, 11],
      "darkgray": [169, 169, 169],
      "darkgreen": [0, 100, 0],
      "darkgrey": [169, 169, 169],
      "darkkhaki": [189, 183, 107],
      "darkmagenta": [139, 0, 139],
      "darkolivegreen": [85, 107, 47],
      "darkorange": [255, 140, 0],
      "darkorchid": [153, 50, 204],
      "darkred": [139, 0, 0],
      "darksalmon": [233, 150, 122],
      "darkseagreen": [143, 188, 143],
      "darkslateblue": [72, 61, 139],
      "darkslategray": [47, 79, 79],
      "darkslategrey": [47, 79, 79],
      "darkturquoise": [0, 206, 209],
      "darkviolet": [148, 0, 211],
      "deeppink": [255, 20, 147],
      "deepskyblue": [0, 191, 255],
      "dimgray": [105, 105, 105],
      "dimgrey": [105, 105, 105],
      "dodgerblue": [30, 144, 255],
      "firebrick": [178, 34, 34],
      "floralwhite": [255, 250, 240],
      "forestgreen": [34, 139, 34],
      "fuchsia": [255, 0, 255],
      "gainsboro": [220, 220, 220],
      "ghostwhite": [248, 248, 255],
      "gold": [255, 215, 0],
      "goldenrod": [218, 165, 32],
      "gray": [128, 128, 128],
      "green": [0, 128, 0],
      "greenyellow": [173, 255, 47],
      "grey": [128, 128, 128],
      "honeydew": [240, 255, 240],
      "hotpink": [255, 105, 180],
      "indianred": [205, 92, 92],
      "indigo": [75, 0, 130],
      "ivory": [255, 255, 240],
      "khaki": [240, 230, 140],
      "lavender": [230, 230, 250],
      "lavenderblush": [255, 240, 245],
      "lawngreen": [124, 252, 0],
      "lemonchiffon": [255, 250, 205],
      "lightblue": [173, 216, 230],
      "lightcoral": [240, 128, 128],
      "lightcyan": [224, 255, 255],
      "lightgoldenrodyellow": [250, 250, 210],
      "lightgray": [211, 211, 211],
      "lightgreen": [144, 238, 144],
      "lightgrey": [211, 211, 211],
      "lightpink": [255, 182, 193],
      "lightsalmon": [255, 160, 122],
      "lightseagreen": [32, 178, 170],
      "lightskyblue": [135, 206, 250],
      "lightslategray": [119, 136, 153],
      "lightslategrey": [119, 136, 153],
      "lightsteelblue": [176, 196, 222],
      "lightyellow": [255, 255, 224],
      "lime": [0, 255, 0],
      "limegreen": [50, 205, 50],
      "linen": [250, 240, 230],
      "magenta": [255, 0, 255],
      "maroon": [128, 0, 0],
      "mediumaquamarine": [102, 205, 170],
      "mediumblue": [0, 0, 205],
      "mediumorchid": [186, 85, 211],
      "mediumpurple": [147, 112, 219],
      "mediumseagreen": [60, 179, 113],
      "mediumslateblue": [123, 104, 238],
      "mediumspringgreen": [0, 250, 154],
      "mediumturquoise": [72, 209, 204],
      "mediumvioletred": [199, 21, 133],
      "midnightblue": [25, 25, 112],
      "mintcream": [245, 255, 250],
      "mistyrose": [255, 228, 225],
      "moccasin": [255, 228, 181],
      "navajowhite": [255, 222, 173],
      "navy": [0, 0, 128],
      "oldlace": [253, 245, 230],
      "olive": [128, 128, 0],
      "olivedrab": [107, 142, 35],
      "orange": [255, 165, 0],
      "orangered": [255, 69, 0],
      "orchid": [218, 112, 214],
      "palegoldenrod": [238, 232, 170],
      "palegreen": [152, 251, 152],
      "paleturquoise": [175, 238, 238],
      "palevioletred": [219, 112, 147],
      "papayawhip": [255, 239, 213],
      "peachpuff": [255, 218, 185],
      "peru": [205, 133, 63],
      "pink": [255, 192, 203],
      "plum": [221, 160, 221],
      "powderblue": [176, 224, 230],
      "purple": [128, 0, 128],
      "rebeccapurple": [102, 51, 153],
      "red": [255, 0, 0],
      "rosybrown": [188, 143, 143],
      "royalblue": [65, 105, 225],
      "saddlebrown": [139, 69, 19],
      "salmon": [250, 128, 114],
      "sandybrown": [244, 164, 96],
      "seagreen": [46, 139, 87],
      "seashell": [255, 245, 238],
      "sienna": [160, 82, 45],
      "silver": [192, 192, 192],
      "skyblue": [135, 206, 235],
      "slateblue": [106, 90, 205],
      "slategray": [112, 128, 144],
      "slategrey": [112, 128, 144],
      "snow": [255, 250, 250],
      "springgreen": [0, 255, 127],
      "steelblue": [70, 130, 180],
      "tan": [210, 180, 140],
      "teal": [0, 128, 128],
      "thistle": [216, 191, 216],
      "tomato": [255, 99, 71],
      "turquoise": [64, 224, 208],
      "violet": [238, 130, 238],
      "wheat": [245, 222, 179],
      "white": [255, 255, 255],
      "whitesmoke": [245, 245, 245],
      "yellow": [255, 255, 0],
      "yellowgreen": [154, 205, 50]
    };
  }
});

// node_modules/@babel/highlight/node_modules/color-convert/conversions.js
var require_conversions = __commonJS({
  "node_modules/@babel/highlight/node_modules/color-convert/conversions.js"(exports, module2) {
    var cssKeywords = require_color_name();
    var reverseKeywords = {};
    for (key2 in cssKeywords) {
      if (cssKeywords.hasOwnProperty(key2)) {
        reverseKeywords[cssKeywords[key2]] = key2;
      }
    }
    var key2;
    var convert2 = module2.exports = {
      rgb: { channels: 3, labels: "rgb" },
      hsl: { channels: 3, labels: "hsl" },
      hsv: { channels: 3, labels: "hsv" },
      hwb: { channels: 3, labels: "hwb" },
      cmyk: { channels: 4, labels: "cmyk" },
      xyz: { channels: 3, labels: "xyz" },
      lab: { channels: 3, labels: "lab" },
      lch: { channels: 3, labels: "lch" },
      hex: { channels: 1, labels: ["hex"] },
      keyword: { channels: 1, labels: ["keyword"] },
      ansi16: { channels: 1, labels: ["ansi16"] },
      ansi256: { channels: 1, labels: ["ansi256"] },
      hcg: { channels: 3, labels: ["h", "c", "g"] },
      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
      gray: { channels: 1, labels: ["gray"] }
    };
    for (model in convert2) {
      if (convert2.hasOwnProperty(model)) {
        if (!("channels" in convert2[model])) {
          throw new Error("missing channels property: " + model);
        }
        if (!("labels" in convert2[model])) {
          throw new Error("missing channel labels property: " + model);
        }
        if (convert2[model].labels.length !== convert2[model].channels) {
          throw new Error("channel and label counts mismatch: " + model);
        }
        channels = convert2[model].channels;
        labels = convert2[model].labels;
        delete convert2[model].channels;
        delete convert2[model].labels;
        Object.defineProperty(convert2[model], "channels", { value: channels });
        Object.defineProperty(convert2[model], "labels", { value: labels });
      }
    }
    var channels;
    var labels;
    var model;
    convert2.rgb.hsl = function(rgb) {
      var r = rgb[0] / 255;
      var g = rgb[1] / 255;
      var b = rgb[2] / 255;
      var min = Math.min(r, g, b);
      var max = Math.max(r, g, b);
      var delta = max - min;
      var h;
      var s;
      var l;
      if (max === min) {
        h = 0;
      } else if (r === max) {
        h = (g - b) / delta;
      } else if (g === max) {
        h = 2 + (b - r) / delta;
      } else if (b === max) {
        h = 4 + (r - g) / delta;
      }
      h = Math.min(h * 60, 360);
      if (h < 0) {
        h += 360;
      }
      l = (min + max) / 2;
      if (max === min) {
        s = 0;
      } else if (l <= 0.5) {
        s = delta / (max + min);
      } else {
        s = delta / (2 - max - min);
      }
      return [h, s * 100, l * 100];
    };
    convert2.rgb.hsv = function(rgb) {
      var rdif;
      var gdif;
      var bdif;
      var h;
      var s;
      var r = rgb[0] / 255;
      var g = rgb[1] / 255;
      var b = rgb[2] / 255;
      var v = Math.max(r, g, b);
      var diff = v - Math.min(r, g, b);
      var diffc = function(c2) {
        return (v - c2) / 6 / diff + 1 / 2;
      };
      if (diff === 0) {
        h = s = 0;
      } else {
        s = diff / v;
        rdif = diffc(r);
        gdif = diffc(g);
        bdif = diffc(b);
        if (r === v) {
          h = bdif - gdif;
        } else if (g === v) {
          h = 1 / 3 + rdif - bdif;
        } else if (b === v) {
          h = 2 / 3 + gdif - rdif;
        }
        if (h < 0) {
          h += 1;
        } else if (h > 1) {
          h -= 1;
        }
      }
      return [
        h * 360,
        s * 100,
        v * 100
      ];
    };
    convert2.rgb.hwb = function(rgb) {
      var r = rgb[0];
      var g = rgb[1];
      var b = rgb[2];
      var h = convert2.rgb.hsl(rgb)[0];
      var w = 1 / 255 * Math.min(r, Math.min(g, b));
      b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
      return [h, w * 100, b * 100];
    };
    convert2.rgb.cmyk = function(rgb) {
      var r = rgb[0] / 255;
      var g = rgb[1] / 255;
      var b = rgb[2] / 255;
      var c2;
      var m;
      var y;
      var k;
      k = Math.min(1 - r, 1 - g, 1 - b);
      c2 = (1 - r - k) / (1 - k) || 0;
      m = (1 - g - k) / (1 - k) || 0;
      y = (1 - b - k) / (1 - k) || 0;
      return [c2 * 100, m * 100, y * 100, k * 100];
    };
    function comparativeDistance(x, y) {
      return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
    }
    convert2.rgb.keyword = function(rgb) {
      var reversed = reverseKeywords[rgb];
      if (reversed) {
        return reversed;
      }
      var currentClosestDistance = Infinity;
      var currentClosestKeyword;
      for (var keyword in cssKeywords) {
        if (cssKeywords.hasOwnProperty(keyword)) {
          var value2 = cssKeywords[keyword];
          var distance = comparativeDistance(rgb, value2);
          if (distance < currentClosestDistance) {
            currentClosestDistance = distance;
            currentClosestKeyword = keyword;
          }
        }
      }
      return currentClosestKeyword;
    };
    convert2.keyword.rgb = function(keyword) {
      return cssKeywords[keyword];
    };
    convert2.rgb.xyz = function(rgb) {
      var r = rgb[0] / 255;
      var g = rgb[1] / 255;
      var b = rgb[2] / 255;
      r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
      g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
      b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
      var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
      var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
      var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
      return [x * 100, y * 100, z * 100];
    };
    convert2.rgb.lab = function(rgb) {
      var xyz = convert2.rgb.xyz(rgb);
      var x = xyz[0];
      var y = xyz[1];
      var z = xyz[2];
      var l;
      var a;
      var b;
      x /= 95.047;
      y /= 100;
      z /= 108.883;
      x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
      y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
      z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
      l = 116 * y - 16;
      a = 500 * (x - y);
      b = 200 * (y - z);
      return [l, a, b];
    };
    convert2.hsl.rgb = function(hsl) {
      var h = hsl[0] / 360;
      var s = hsl[1] / 100;
      var l = hsl[2] / 100;
      var t1;
      var t22;
      var t3;
      var rgb;
      var val;
      if (s === 0) {
        val = l * 255;
        return [val, val, val];
      }
      if (l < 0.5) {
        t22 = l * (1 + s);
      } else {
        t22 = l + s - l * s;
      }
      t1 = 2 * l - t22;
      rgb = [0, 0, 0];
      for (var i = 0; i < 3; i++) {
        t3 = h + 1 / 3 * -(i - 1);
        if (t3 < 0) {
          t3++;
        }
        if (t3 > 1) {
          t3--;
        }
        if (6 * t3 < 1) {
          val = t1 + (t22 - t1) * 6 * t3;
        } else if (2 * t3 < 1) {
          val = t22;
        } else if (3 * t3 < 2) {
          val = t1 + (t22 - t1) * (2 / 3 - t3) * 6;
        } else {
          val = t1;
        }
        rgb[i] = val * 255;
      }
      return rgb;
    };
    convert2.hsl.hsv = function(hsl) {
      var h = hsl[0];
      var s = hsl[1] / 100;
      var l = hsl[2] / 100;
      var smin = s;
      var lmin = Math.max(l, 0.01);
      var sv;
      var v;
      l *= 2;
      s *= l <= 1 ? l : 2 - l;
      smin *= lmin <= 1 ? lmin : 2 - lmin;
      v = (l + s) / 2;
      sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
      return [h, sv * 100, v * 100];
    };
    convert2.hsv.rgb = function(hsv) {
      var h = hsv[0] / 60;
      var s = hsv[1] / 100;
      var v = hsv[2] / 100;
      var hi = Math.floor(h) % 6;
      var f = h - Math.floor(h);
      var p = 255 * v * (1 - s);
      var q = 255 * v * (1 - s * f);
      var t3 = 255 * v * (1 - s * (1 - f));
      v *= 255;
      switch (hi) {
        case 0:
          return [v, t3, p];
        case 1:
          return [q, v, p];
        case 2:
          return [p, v, t3];
        case 3:
          return [p, q, v];
        case 4:
          return [t3, p, v];
        case 5:
          return [v, p, q];
      }
    };
    convert2.hsv.hsl = function(hsv) {
      var h = hsv[0];
      var s = hsv[1] / 100;
      var v = hsv[2] / 100;
      var vmin = Math.max(v, 0.01);
      var lmin;
      var sl;
      var l;
      l = (2 - s) * v;
      lmin = (2 - s) * vmin;
      sl = s * vmin;
      sl /= lmin <= 1 ? lmin : 2 - lmin;
      sl = sl || 0;
      l /= 2;
      return [h, sl * 100, l * 100];
    };
    convert2.hwb.rgb = function(hwb) {
      var h = hwb[0] / 360;
      var wh = hwb[1] / 100;
      var bl = hwb[2] / 100;
      var ratio = wh + bl;
      var i;
      var v;
      var f;
      var n;
      if (ratio > 1) {
        wh /= ratio;
        bl /= ratio;
      }
      i = Math.floor(6 * h);
      v = 1 - bl;
      f = 6 * h - i;
      if ((i & 1) !== 0) {
        f = 1 - f;
      }
      n = wh + f * (v - wh);
      var r;
      var g;
      var b;
      switch (i) {
        default:
        case 6:
        case 0:
          r = v;
          g = n;
          b = wh;
          break;
        case 1:
          r = n;
          g = v;
          b = wh;
          break;
        case 2:
          r = wh;
          g = v;
          b = n;
          break;
        case 3:
          r = wh;
          g = n;
          b = v;
          break;
        case 4:
          r = n;
          g = wh;
          b = v;
          break;
        case 5:
          r = v;
          g = wh;
          b = n;
          break;
      }
      return [r * 255, g * 255, b * 255];
    };
    convert2.cmyk.rgb = function(cmyk) {
      var c2 = cmyk[0] / 100;
      var m = cmyk[1] / 100;
      var y = cmyk[2] / 100;
      var k = cmyk[3] / 100;
      var r;
      var g;
      var b;
      r = 1 - Math.min(1, c2 * (1 - k) + k);
      g = 1 - Math.min(1, m * (1 - k) + k);
      b = 1 - Math.min(1, y * (1 - k) + k);
      return [r * 255, g * 255, b * 255];
    };
    convert2.xyz.rgb = function(xyz) {
      var x = xyz[0] / 100;
      var y = xyz[1] / 100;
      var z = xyz[2] / 100;
      var r;
      var g;
      var b;
      r = x * 3.2406 + y * -1.5372 + z * -0.4986;
      g = x * -0.9689 + y * 1.8758 + z * 0.0415;
      b = x * 0.0557 + y * -0.204 + z * 1.057;
      r = r > 31308e-7 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : r * 12.92;
      g = g > 31308e-7 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : g * 12.92;
      b = b > 31308e-7 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : b * 12.92;
      r = Math.min(Math.max(0, r), 1);
      g = Math.min(Math.max(0, g), 1);
      b = Math.min(Math.max(0, b), 1);
      return [r * 255, g * 255, b * 255];
    };
    convert2.xyz.lab = function(xyz) {
      var x = xyz[0];
      var y = xyz[1];
      var z = xyz[2];
      var l;
      var a;
      var b;
      x /= 95.047;
      y /= 100;
      z /= 108.883;
      x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
      y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
      z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
      l = 116 * y - 16;
      a = 500 * (x - y);
      b = 200 * (y - z);
      return [l, a, b];
    };
    convert2.lab.xyz = function(lab) {
      var l = lab[0];
      var a = lab[1];
      var b = lab[2];
      var x;
      var y;
      var z;
      y = (l + 16) / 116;
      x = a / 500 + y;
      z = y - b / 200;
      var y2 = Math.pow(y, 3);
      var x2 = Math.pow(x, 3);
      var z2 = Math.pow(z, 3);
      y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
      x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
      z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
      x *= 95.047;
      y *= 100;
      z *= 108.883;
      return [x, y, z];
    };
    convert2.lab.lch = function(lab) {
      var l = lab[0];
      var a = lab[1];
      var b = lab[2];
      var hr;
      var h;
      var c2;
      hr = Math.atan2(b, a);
      h = hr * 360 / 2 / Math.PI;
      if (h < 0) {
        h += 360;
      }
      c2 = Math.sqrt(a * a + b * b);
      return [l, c2, h];
    };
    convert2.lch.lab = function(lch) {
      var l = lch[0];
      var c2 = lch[1];
      var h = lch[2];
      var a;
      var b;
      var hr;
      hr = h / 360 * 2 * Math.PI;
      a = c2 * Math.cos(hr);
      b = c2 * Math.sin(hr);
      return [l, a, b];
    };
    convert2.rgb.ansi16 = function(args) {
      var r = args[0];
      var g = args[1];
      var b = args[2];
      var value2 = 1 in arguments ? arguments[1] : convert2.rgb.hsv(args)[2];
      value2 = Math.round(value2 / 50);
      if (value2 === 0) {
        return 30;
      }
      var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
      if (value2 === 2) {
        ansi += 60;
      }
      return ansi;
    };
    convert2.hsv.ansi16 = function(args) {
      return convert2.rgb.ansi16(convert2.hsv.rgb(args), args[2]);
    };
    convert2.rgb.ansi256 = function(args) {
      var r = args[0];
      var g = args[1];
      var b = args[2];
      if (r === g && g === b) {
        if (r < 8) {
          return 16;
        }
        if (r > 248) {
          return 231;
        }
        return Math.round((r - 8) / 247 * 24) + 232;
      }
      var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
      return ansi;
    };
    convert2.ansi16.rgb = function(args) {
      var color3 = args % 10;
      if (color3 === 0 || color3 === 7) {
        if (args > 50) {
          color3 += 3.5;
        }
        color3 = color3 / 10.5 * 255;
        return [color3, color3, color3];
      }
      var mult = (~~(args > 50) + 1) * 0.5;
      var r = (color3 & 1) * mult * 255;
      var g = (color3 >> 1 & 1) * mult * 255;
      var b = (color3 >> 2 & 1) * mult * 255;
      return [r, g, b];
    };
    convert2.ansi256.rgb = function(args) {
      if (args >= 232) {
        var c2 = (args - 232) * 10 + 8;
        return [c2, c2, c2];
      }
      args -= 16;
      var rem;
      var r = Math.floor(args / 36) / 5 * 255;
      var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
      var b = rem % 6 / 5 * 255;
      return [r, g, b];
    };
    convert2.rgb.hex = function(args) {
      var integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
      var string3 = integer.toString(16).toUpperCase();
      return "000000".substring(string3.length) + string3;
    };
    convert2.hex.rgb = function(args) {
      var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
      if (!match) {
        return [0, 0, 0];
      }
      var colorString = match[0];
      if (match[0].length === 3) {
        colorString = colorString.split("").map(function(char) {
          return char + char;
        }).join("");
      }
      var integer = parseInt(colorString, 16);
      var r = integer >> 16 & 255;
      var g = integer >> 8 & 255;
      var b = integer & 255;
      return [r, g, b];
    };
    convert2.rgb.hcg = function(rgb) {
      var r = rgb[0] / 255;
      var g = rgb[1] / 255;
      var b = rgb[2] / 255;
      var max = Math.max(Math.max(r, g), b);
      var min = Math.min(Math.min(r, g), b);
      var chroma = max - min;
      var grayscale;
      var hue;
      if (chroma < 1) {
        grayscale = min / (1 - chroma);
      } else {
        grayscale = 0;
      }
      if (chroma <= 0) {
        hue = 0;
      } else if (max === r) {
        hue = (g - b) / chroma % 6;
      } else if (max === g) {
        hue = 2 + (b - r) / chroma;
      } else {
        hue = 4 + (r - g) / chroma + 4;
      }
      hue /= 6;
      hue %= 1;
      return [hue * 360, chroma * 100, grayscale * 100];
    };
    convert2.hsl.hcg = function(hsl) {
      var s = hsl[1] / 100;
      var l = hsl[2] / 100;
      var c2 = 1;
      var f = 0;
      if (l < 0.5) {
        c2 = 2 * s * l;
      } else {
        c2 = 2 * s * (1 - l);
      }
      if (c2 < 1) {
        f = (l - 0.5 * c2) / (1 - c2);
      }
      return [hsl[0], c2 * 100, f * 100];
    };
    convert2.hsv.hcg = function(hsv) {
      var s = hsv[1] / 100;
      var v = hsv[2] / 100;
      var c2 = s * v;
      var f = 0;
      if (c2 < 1) {
        f = (v - c2) / (1 - c2);
      }
      return [hsv[0], c2 * 100, f * 100];
    };
    convert2.hcg.rgb = function(hcg) {
      var h = hcg[0] / 360;
      var c2 = hcg[1] / 100;
      var g = hcg[2] / 100;
      if (c2 === 0) {
        return [g * 255, g * 255, g * 255];
      }
      var pure = [0, 0, 0];
      var hi = h % 1 * 6;
      var v = hi % 1;
      var w = 1 - v;
      var mg = 0;
      switch (Math.floor(hi)) {
        case 0:
          pure[0] = 1;
          pure[1] = v;
          pure[2] = 0;
          break;
        case 1:
          pure[0] = w;
          pure[1] = 1;
          pure[2] = 0;
          break;
        case 2:
          pure[0] = 0;
          pure[1] = 1;
          pure[2] = v;
          break;
        case 3:
          pure[0] = 0;
          pure[1] = w;
          pure[2] = 1;
          break;
        case 4:
          pure[0] = v;
          pure[1] = 0;
          pure[2] = 1;
          break;
        default:
          pure[0] = 1;
          pure[1] = 0;
          pure[2] = w;
      }
      mg = (1 - c2) * g;
      return [
        (c2 * pure[0] + mg) * 255,
        (c2 * pure[1] + mg) * 255,
        (c2 * pure[2] + mg) * 255
      ];
    };
    convert2.hcg.hsv = function(hcg) {
      var c2 = hcg[1] / 100;
      var g = hcg[2] / 100;
      var v = c2 + g * (1 - c2);
      var f = 0;
      if (v > 0) {
        f = c2 / v;
      }
      return [hcg[0], f * 100, v * 100];
    };
    convert2.hcg.hsl = function(hcg) {
      var c2 = hcg[1] / 100;
      var g = hcg[2] / 100;
      var l = g * (1 - c2) + 0.5 * c2;
      var s = 0;
      if (l > 0 && l < 0.5) {
        s = c2 / (2 * l);
      } else if (l >= 0.5 && l < 1) {
        s = c2 / (2 * (1 - l));
      }
      return [hcg[0], s * 100, l * 100];
    };
    convert2.hcg.hwb = function(hcg) {
      var c2 = hcg[1] / 100;
      var g = hcg[2] / 100;
      var v = c2 + g * (1 - c2);
      return [hcg[0], (v - c2) * 100, (1 - v) * 100];
    };
    convert2.hwb.hcg = function(hwb) {
      var w = hwb[1] / 100;
      var b = hwb[2] / 100;
      var v = 1 - b;
      var c2 = v - w;
      var g = 0;
      if (c2 < 1) {
        g = (v - c2) / (1 - c2);
      }
      return [hwb[0], c2 * 100, g * 100];
    };
    convert2.apple.rgb = function(apple) {
      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
    };
    convert2.rgb.apple = function(rgb) {
      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
    };
    convert2.gray.rgb = function(args) {
      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
    };
    convert2.gray.hsl = convert2.gray.hsv = function(args) {
      return [0, 0, args[0]];
    };
    convert2.gray.hwb = function(gray) {
      return [0, 100, gray[0]];
    };
    convert2.gray.cmyk = function(gray) {
      return [0, 0, 0, gray[0]];
    };
    convert2.gray.lab = function(gray) {
      return [gray[0], 0, 0];
    };
    convert2.gray.hex = function(gray) {
      var val = Math.round(gray[0] / 100 * 255) & 255;
      var integer = (val << 16) + (val << 8) + val;
      var string3 = integer.toString(16).toUpperCase();
      return "000000".substring(string3.length) + string3;
    };
    convert2.rgb.gray = function(rgb) {
      var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
      return [val / 255 * 100];
    };
  }
});

// node_modules/@babel/highlight/node_modules/color-convert/route.js
var require_route = __commonJS({
  "node_modules/@babel/highlight/node_modules/color-convert/route.js"(exports, module2) {
    var conversions = require_conversions();
    function buildGraph() {
      var graph = {};
      var models = Object.keys(conversions);
      for (var len = models.length, i = 0; i < len; i++) {
        graph[models[i]] = {
          // http://jsperf.com/1-vs-infinity
          // micro-opt, but this is simple.
          distance: -1,
          parent: null
        };
      }
      return graph;
    }
    function deriveBFS(fromModel) {
      var graph = buildGraph();
      var queue = [fromModel];
      graph[fromModel].distance = 0;
      while (queue.length) {
        var current3 = queue.pop();
        var adjacents = Object.keys(conversions[current3]);
        for (var len = adjacents.length, i = 0; i < len; i++) {
          var adjacent = adjacents[i];
          var node2 = graph[adjacent];
          if (node2.distance === -1) {
            node2.distance = graph[current3].distance + 1;
            node2.parent = current3;
            queue.unshift(adjacent);
          }
        }
      }
      return graph;
    }
    function link2(from, to) {
      return function(args) {
        return to(from(args));
      };
    }
    function wrapConversion(toModel, graph) {
      var path = [graph[toModel].parent, toModel];
      var fn = conversions[graph[toModel].parent][toModel];
      var cur = graph[toModel].parent;
      while (graph[cur].parent) {
        path.unshift(graph[cur].parent);
        fn = link2(conversions[graph[cur].parent][cur], fn);
        cur = graph[cur].parent;
      }
      fn.conversion = path;
      return fn;
    }
    module2.exports = function(fromModel) {
      var graph = deriveBFS(fromModel);
      var conversion = {};
      var models = Object.keys(graph);
      for (var len = models.length, i = 0; i < len; i++) {
        var toModel = models[i];
        var node2 = graph[toModel];
        if (node2.parent === null) {
          continue;
        }
        conversion[toModel] = wrapConversion(toModel, graph);
      }
      return conversion;
    };
  }
});

// node_modules/@babel/highlight/node_modules/color-convert/index.js
var require_color_convert = __commonJS({
  "node_modules/@babel/highlight/node_modules/color-convert/index.js"(exports, module2) {
    var conversions = require_conversions();
    var route = require_route();
    var convert2 = {};
    var models = Object.keys(conversions);
    function wrapRaw(fn) {
      var wrappedFn = function(args) {
        if (args === void 0 || args === null) {
          return args;
        }
        if (arguments.length > 1) {
          args = Array.prototype.slice.call(arguments);
        }
        return fn(args);
      };
      if ("conversion" in fn) {
        wrappedFn.conversion = fn.conversion;
      }
      return wrappedFn;
    }
    function wrapRounded(fn) {
      var wrappedFn = function(args) {
        if (args === void 0 || args === null) {
          return args;
        }
        if (arguments.length > 1) {
          args = Array.prototype.slice.call(arguments);
        }
        var result = fn(args);
        if (typeof result === "object") {
          for (var len = result.length, i = 0; i < len; i++) {
            result[i] = Math.round(result[i]);
          }
        }
        return result;
      };
      if ("conversion" in fn) {
        wrappedFn.conversion = fn.conversion;
      }
      return wrappedFn;
    }
    models.forEach(function(fromModel) {
      convert2[fromModel] = {};
      Object.defineProperty(convert2[fromModel], "channels", { value: conversions[fromModel].channels });
      Object.defineProperty(convert2[fromModel], "labels", { value: conversions[fromModel].labels });
      var routes = route(fromModel);
      var routeModels = Object.keys(routes);
      routeModels.forEach(function(toModel) {
        var fn = routes[toModel];
        convert2[fromModel][toModel] = wrapRounded(fn);
        convert2[fromModel][toModel].raw = wrapRaw(fn);
      });
    });
    module2.exports = convert2;
  }
});

// node_modules/@babel/highlight/node_modules/ansi-styles/index.js
var require_ansi_styles = __commonJS({
  "node_modules/@babel/highlight/node_modules/ansi-styles/index.js"(exports, module2) {
    "use strict";
    var colorConvert = require_color_convert();
    var wrapAnsi16 = (fn, offset3) => function() {
      const code2 = fn.apply(colorConvert, arguments);
      return `\x1B[${code2 + offset3}m`;
    };
    var wrapAnsi256 = (fn, offset3) => function() {
      const code2 = fn.apply(colorConvert, arguments);
      return `\x1B[${38 + offset3};5;${code2}m`;
    };
    var wrapAnsi16m = (fn, offset3) => function() {
      const rgb = fn.apply(colorConvert, arguments);
      return `\x1B[${38 + offset3};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
    };
    function assembleStyles() {
      const codes = /* @__PURE__ */ new Map();
      const styles = {
        modifier: {
          reset: [0, 0],
          // 21 isn't widely supported and 22 does the same thing
          bold: [1, 22],
          dim: [2, 22],
          italic: [3, 23],
          underline: [4, 24],
          inverse: [7, 27],
          hidden: [8, 28],
          strikethrough: [9, 29]
        },
        color: {
          black: [30, 39],
          red: [31, 39],
          green: [32, 39],
          yellow: [33, 39],
          blue: [34, 39],
          magenta: [35, 39],
          cyan: [36, 39],
          white: [37, 39],
          gray: [90, 39],
          // Bright color
          redBright: [91, 39],
          greenBright: [92, 39],
          yellowBright: [93, 39],
          blueBright: [94, 39],
          magentaBright: [95, 39],
          cyanBright: [96, 39],
          whiteBright: [97, 39]
        },
        bgColor: {
          bgBlack: [40, 49],
          bgRed: [41, 49],
          bgGreen: [42, 49],
          bgYellow: [43, 49],
          bgBlue: [44, 49],
          bgMagenta: [45, 49],
          bgCyan: [46, 49],
          bgWhite: [47, 49],
          // Bright color
          bgBlackBright: [100, 49],
          bgRedBright: [101, 49],
          bgGreenBright: [102, 49],
          bgYellowBright: [103, 49],
          bgBlueBright: [104, 49],
          bgMagentaBright: [105, 49],
          bgCyanBright: [106, 49],
          bgWhiteBright: [107, 49]
        }
      };
      styles.color.grey = styles.color.gray;
      for (const groupName of Object.keys(styles)) {
        const group = styles[groupName];
        for (const styleName of Object.keys(group)) {
          const style = group[styleName];
          styles[styleName] = {
            open: `\x1B[${style[0]}m`,
            close: `\x1B[${style[1]}m`
          };
          group[styleName] = styles[styleName];
          codes.set(style[0], style[1]);
        }
        Object.defineProperty(styles, groupName, {
          value: group,
          enumerable: false
        });
        Object.defineProperty(styles, "codes", {
          value: codes,
          enumerable: false
        });
      }
      const ansi2ansi = (n) => n;
      const rgb2rgb = (r, g, b) => [r, g, b];
      styles.color.close = "\x1B[39m";
      styles.bgColor.close = "\x1B[49m";
      styles.color.ansi = {
        ansi: wrapAnsi16(ansi2ansi, 0)
      };
      styles.color.ansi256 = {
        ansi256: wrapAnsi256(ansi2ansi, 0)
      };
      styles.color.ansi16m = {
        rgb: wrapAnsi16m(rgb2rgb, 0)
      };
      styles.bgColor.ansi = {
        ansi: wrapAnsi16(ansi2ansi, 10)
      };
      styles.bgColor.ansi256 = {
        ansi256: wrapAnsi256(ansi2ansi, 10)
      };
      styles.bgColor.ansi16m = {
        rgb: wrapAnsi16m(rgb2rgb, 10)
      };
      for (let key2 of Object.keys(colorConvert)) {
        if (typeof colorConvert[key2] !== "object") {
          continue;
        }
        const suite = colorConvert[key2];
        if (key2 === "ansi16") {
          key2 = "ansi";
        }
        if ("ansi16" in suite) {
          styles.color.ansi[key2] = wrapAnsi16(suite.ansi16, 0);
          styles.bgColor.ansi[key2] = wrapAnsi16(suite.ansi16, 10);
        }
        if ("ansi256" in suite) {
          styles.color.ansi256[key2] = wrapAnsi256(suite.ansi256, 0);
          styles.bgColor.ansi256[key2] = wrapAnsi256(suite.ansi256, 10);
        }
        if ("rgb" in suite) {
          styles.color.ansi16m[key2] = wrapAnsi16m(suite.rgb, 0);
          styles.bgColor.ansi16m[key2] = wrapAnsi16m(suite.rgb, 10);
        }
      }
      return styles;
    }
    Object.defineProperty(module2, "exports", {
      enumerable: true,
      get: assembleStyles
    });
  }
});

// node_modules/@babel/highlight/node_modules/has-flag/index.js
var require_has_flag2 = __commonJS({
  "node_modules/@babel/highlight/node_modules/has-flag/index.js"(exports, module2) {
    "use strict";
    module2.exports = (flag, argv) => {
      argv = argv || process.argv;
      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
      const pos2 = argv.indexOf(prefix + flag);
      const terminatorPos = argv.indexOf("--");
      return pos2 !== -1 && (terminatorPos === -1 ? true : pos2 < terminatorPos);
    };
  }
});

// node_modules/@babel/highlight/node_modules/supports-color/index.js
var require_supports_color2 = __commonJS({
  "node_modules/@babel/highlight/node_modules/supports-color/index.js"(exports, module2) {
    "use strict";
    var os = require("os");
    var hasFlag = require_has_flag2();
    var env = process.env;
    var forceColor;
    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
      forceColor = false;
    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
      forceColor = true;
    }
    if ("FORCE_COLOR" in env) {
      forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
    }
    function translateLevel(level) {
      if (level === 0) {
        return false;
      }
      return {
        level,
        hasBasic: true,
        has256: level >= 2,
        has16m: level >= 3
      };
    }
    function supportsColor(stream) {
      if (forceColor === false) {
        return 0;
      }
      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
        return 3;
      }
      if (hasFlag("color=256")) {
        return 2;
      }
      if (stream && !stream.isTTY && forceColor !== true) {
        return 0;
      }
      const min = forceColor ? 1 : 0;
      if (process.platform === "win32") {
        const osRelease = os.release().split(".");
        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
          return Number(osRelease[2]) >= 14931 ? 3 : 2;
        }
        return 1;
      }
      if ("CI" in env) {
        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign2) => sign2 in env) || env.CI_NAME === "codeship") {
          return 1;
        }
        return min;
      }
      if ("TEAMCITY_VERSION" in env) {
        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
      }
      if (env.COLORTERM === "truecolor") {
        return 3;
      }
      if ("TERM_PROGRAM" in env) {
        const version3 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
        switch (env.TERM_PROGRAM) {
          case "iTerm.app":
            return version3 >= 3 ? 3 : 2;
          case "Apple_Terminal":
            return 2;
        }
      }
      if (/-256(color)?$/i.test(env.TERM)) {
        return 2;
      }
      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
        return 1;
      }
      if ("COLORTERM" in env) {
        return 1;
      }
      if (env.TERM === "dumb") {
        return min;
      }
      return min;
    }
    function getSupportLevel(stream) {
      const level = supportsColor(stream);
      return translateLevel(level);
    }
    module2.exports = {
      supportsColor: getSupportLevel,
      stdout: getSupportLevel(process.stdout),
      stderr: getSupportLevel(process.stderr)
    };
  }
});

// node_modules/@babel/highlight/node_modules/chalk/templates.js
var require_templates = __commonJS({
  "node_modules/@babel/highlight/node_modules/chalk/templates.js"(exports, module2) {
    "use strict";
    var TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
    var ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
    var ESCAPES = /* @__PURE__ */ new Map([
      ["n", "\n"],
      ["r", "\r"],
      ["t", "	"],
      ["b", "\b"],
      ["f", "\f"],
      ["v", "\v"],
      ["0", "\0"],
      ["\\", "\\"],
      ["e", "\x1B"],
      ["a", "\x07"]
    ]);
    function unescape2(c2) {
      if (c2[0] === "u" && c2.length === 5 || c2[0] === "x" && c2.length === 3) {
        return String.fromCharCode(parseInt(c2.slice(1), 16));
      }
      return ESCAPES.get(c2) || c2;
    }
    function parseArguments(name2, args) {
      const results = [];
      const chunks = args.trim().split(/\s*,\s*/g);
      let matches;
      for (const chunk of chunks) {
        if (!isNaN(chunk)) {
          results.push(Number(chunk));
        } else if (matches = chunk.match(STRING_REGEX)) {
          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape3, chr) => escape3 ? unescape2(escape3) : chr));
        } else {
          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name2}')`);
        }
      }
      return results;
    }
    function parseStyle2(style) {
      STYLE_REGEX.lastIndex = 0;
      const results = [];
      let matches;
      while ((matches = STYLE_REGEX.exec(style)) !== null) {
        const name2 = matches[1];
        if (matches[2]) {
          const args = parseArguments(name2, matches[2]);
          results.push([name2].concat(args));
        } else {
          results.push([name2]);
        }
      }
      return results;
    }
    function buildStyle(chalk, styles) {
      const enabled = {};
      for (const layer of styles) {
        for (const style of layer.styles) {
          enabled[style[0]] = layer.inverse ? null : style.slice(1);
        }
      }
      let current3 = chalk;
      for (const styleName of Object.keys(enabled)) {
        if (Array.isArray(enabled[styleName])) {
          if (!(styleName in current3)) {
            throw new Error(`Unknown Chalk style: ${styleName}`);
          }
          if (enabled[styleName].length > 0) {
            current3 = current3[styleName].apply(current3, enabled[styleName]);
          } else {
            current3 = current3[styleName];
          }
        }
      }
      return current3;
    }
    module2.exports = (chalk, tmp) => {
      const styles = [];
      const chunks = [];
      let chunk = [];
      tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
        if (escapeChar) {
          chunk.push(unescape2(escapeChar));
        } else if (style) {
          const str = chunk.join("");
          chunk = [];
          chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
          styles.push({ inverse, styles: parseStyle2(style) });
        } else if (close) {
          if (styles.length === 0) {
            throw new Error("Found extraneous } in Chalk template literal");
          }
          chunks.push(buildStyle(chalk, styles)(chunk.join("")));
          chunk = [];
          styles.pop();
        } else {
          chunk.push(chr);
        }
      });
      chunks.push(chunk.join(""));
      if (styles.length > 0) {
        const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
        throw new Error(errMsg);
      }
      return chunks.join("");
    };
  }
});

// node_modules/@babel/highlight/node_modules/chalk/index.js
var require_chalk = __commonJS({
  "node_modules/@babel/highlight/node_modules/chalk/index.js"(exports, module2) {
    "use strict";
    var escapeStringRegexp = require_escape_string_regexp();
    var ansiStyles = require_ansi_styles();
    var stdoutColor = require_supports_color2().stdout;
    var template = require_templates();
    var isSimpleWindowsTerm = process.platform === "win32" && !(process.env.TERM || "").toLowerCase().startsWith("xterm");
    var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
    var skipModels = /* @__PURE__ */ new Set(["gray"]);
    var styles = /* @__PURE__ */ Object.create(null);
    function applyOptions(obj, options) {
      options = options || {};
      const scLevel = stdoutColor ? stdoutColor.level : 0;
      obj.level = options.level === void 0 ? scLevel : options.level;
      obj.enabled = "enabled" in options ? options.enabled : obj.level > 0;
    }
    function Chalk(options) {
      if (!this || !(this instanceof Chalk) || this.template) {
        const chalk = {};
        applyOptions(chalk, options);
        chalk.template = function() {
          const args = [].slice.call(arguments);
          return chalkTag.apply(null, [chalk.template].concat(args));
        };
        Object.setPrototypeOf(chalk, Chalk.prototype);
        Object.setPrototypeOf(chalk.template, chalk);
        chalk.template.constructor = Chalk;
        return chalk.template;
      }
      applyOptions(this, options);
    }
    if (isSimpleWindowsTerm) {
      ansiStyles.blue.open = "\x1B[94m";
    }
    for (const key2 of Object.keys(ansiStyles)) {
      ansiStyles[key2].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key2].close), "g");
      styles[key2] = {
        get() {
          const codes = ansiStyles[key2];
          return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key2);
        }
      };
    }
    styles.visible = {
      get() {
        return build.call(this, this._styles || [], true, "visible");
      }
    };
    ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), "g");
    for (const model of Object.keys(ansiStyles.color.ansi)) {
      if (skipModels.has(model)) {
        continue;
      }
      styles[model] = {
        get() {
          const level = this.level;
          return function() {
            const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
            const codes = {
              open,
              close: ansiStyles.color.close,
              closeRe: ansiStyles.color.closeRe
            };
            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
          };
        }
      };
    }
    ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), "g");
    for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
      if (skipModels.has(model)) {
        continue;
      }
      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
      styles[bgModel] = {
        get() {
          const level = this.level;
          return function() {
            const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
            const codes = {
              open,
              close: ansiStyles.bgColor.close,
              closeRe: ansiStyles.bgColor.closeRe
            };
            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
          };
        }
      };
    }
    var proto = Object.defineProperties(() => {
    }, styles);
    function build(_styles, _empty, key2) {
      const builder = function() {
        return applyStyle.apply(builder, arguments);
      };
      builder._styles = _styles;
      builder._empty = _empty;
      const self2 = this;
      Object.defineProperty(builder, "level", {
        enumerable: true,
        get() {
          return self2.level;
        },
        set(level) {
          self2.level = level;
        }
      });
      Object.defineProperty(builder, "enabled", {
        enumerable: true,
        get() {
          return self2.enabled;
        },
        set(enabled) {
          self2.enabled = enabled;
        }
      });
      builder.hasGrey = this.hasGrey || key2 === "gray" || key2 === "grey";
      builder.__proto__ = proto;
      return builder;
    }
    function applyStyle() {
      const args = arguments;
      const argsLen = args.length;
      let str = String(arguments[0]);
      if (argsLen === 0) {
        return "";
      }
      if (argsLen > 1) {
        for (let a = 1; a < argsLen; a++) {
          str += " " + args[a];
        }
      }
      if (!this.enabled || this.level <= 0 || !str) {
        return this._empty ? "" : str;
      }
      const originalDim = ansiStyles.dim.open;
      if (isSimpleWindowsTerm && this.hasGrey) {
        ansiStyles.dim.open = "";
      }
      for (const code2 of this._styles.slice().reverse()) {
        str = code2.open + str.replace(code2.closeRe, code2.open) + code2.close;
        str = str.replace(/\r?\n/g, `${code2.close}$&${code2.open}`);
      }
      ansiStyles.dim.open = originalDim;
      return str;
    }
    function chalkTag(chalk, strings) {
      if (!Array.isArray(strings)) {
        return [].slice.call(arguments, 1).join(" ");
      }
      const args = [].slice.call(arguments, 2);
      const parts = [strings.raw[0]];
      for (let i = 1; i < strings.length; i++) {
        parts.push(String(args[i - 1]).replace(/[{}\\]/g, "\\$&"));
        parts.push(String(strings.raw[i]));
      }
      return template(chalk, parts.join(""));
    }
    Object.defineProperties(Chalk.prototype, styles);
    module2.exports = Chalk();
    module2.exports.supportsColor = stdoutColor;
    module2.exports.default = module2.exports;
  }
});

// node_modules/@babel/highlight/lib/index.js
var require_lib7 = __commonJS({
  "node_modules/@babel/highlight/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = highlight;
    exports.getChalk = getChalk;
    exports.shouldHighlight = shouldHighlight;
    var _jsTokens = require_js_tokens();
    var _helperValidatorIdentifier = require_lib();
    var _chalk = require_chalk();
    var sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
    function getDefs(chalk) {
      return {
        keyword: chalk.cyan,
        capitalized: chalk.yellow,
        jsxIdentifier: chalk.yellow,
        punctuator: chalk.yellow,
        number: chalk.magenta,
        string: chalk.green,
        regex: chalk.magenta,
        comment: chalk.grey,
        invalid: chalk.white.bgRed.bold
      };
    }
    var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
    var BRACKET = /^[()[\]{}]$/;
    var tokenize;
    {
      const JSX_TAG = /^[a-z][\w-]*$/i;
      const getTokenType = function(token2, offset3, text5) {
        if (token2.type === "name") {
          if ((0, _helperValidatorIdentifier.isKeyword)(token2.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token2.value, true) || sometimesKeywords.has(token2.value)) {
            return "keyword";
          }
          if (JSX_TAG.test(token2.value) && (text5[offset3 - 1] === "<" || text5.slice(offset3 - 2, offset3) == "</")) {
            return "jsxIdentifier";
          }
          if (token2.value[0] !== token2.value[0].toLowerCase()) {
            return "capitalized";
          }
        }
        if (token2.type === "punctuator" && BRACKET.test(token2.value)) {
          return "bracket";
        }
        if (token2.type === "invalid" && (token2.value === "@" || token2.value === "#")) {
          return "punctuator";
        }
        return token2.type;
      };
      tokenize = function* (text5) {
        let match;
        while (match = _jsTokens.default.exec(text5)) {
          const token2 = _jsTokens.matchToToken(match);
          yield {
            type: getTokenType(token2, match.index, text5),
            value: token2.value
          };
        }
      };
    }
    function highlightTokens(defs, text5) {
      let highlighted = "";
      for (const {
        type,
        value: value2
      } of tokenize(text5)) {
        const colorize = defs[type];
        if (colorize) {
          highlighted += value2.split(NEWLINE).map((str) => colorize(str)).join("\n");
        } else {
          highlighted += value2;
        }
      }
      return highlighted;
    }
    function shouldHighlight(options) {
      return !!_chalk.supportsColor || options.forceColor;
    }
    function getChalk(options) {
      return options.forceColor ? new _chalk.constructor({
        enabled: true,
        level: 1
      }) : _chalk;
    }
    function highlight(code2, options = {}) {
      if (code2 !== "" && shouldHighlight(options)) {
        const chalk = getChalk(options);
        const defs = getDefs(chalk);
        return highlightTokens(defs, code2);
      } else {
        return code2;
      }
    }
  }
});

// node_modules/@babel/code-frame/lib/index.js
var require_lib8 = __commonJS({
  "node_modules/@babel/code-frame/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.codeFrameColumns = codeFrameColumns;
    exports.default = _default;
    var _highlight = require_lib7();
    var deprecationWarningShown = false;
    function getDefs(chalk) {
      return {
        gutter: chalk.grey,
        marker: chalk.red.bold,
        message: chalk.red.bold
      };
    }
    var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
    function getMarkerLines(loc, source2, opts) {
      const startLoc = Object.assign({
        column: 0,
        line: -1
      }, loc.start);
      const endLoc = Object.assign({}, startLoc, loc.end);
      const {
        linesAbove = 2,
        linesBelow = 3
      } = opts || {};
      const startLine = startLoc.line;
      const startColumn = startLoc.column;
      const endLine = endLoc.line;
      const endColumn = endLoc.column;
      let start3 = Math.max(startLine - (linesAbove + 1), 0);
      let end = Math.min(source2.length, endLine + linesBelow);
      if (startLine === -1) {
        start3 = 0;
      }
      if (endLine === -1) {
        end = source2.length;
      }
      const lineDiff = endLine - startLine;
      const markerLines = {};
      if (lineDiff) {
        for (let i = 0; i <= lineDiff; i++) {
          const lineNumber = i + startLine;
          if (!startColumn) {
            markerLines[lineNumber] = true;
          } else if (i === 0) {
            const sourceLength = source2[lineNumber - 1].length;
            markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
          } else if (i === lineDiff) {
            markerLines[lineNumber] = [0, endColumn];
          } else {
            const sourceLength = source2[lineNumber - i].length;
            markerLines[lineNumber] = [0, sourceLength];
          }
        }
      } else {
        if (startColumn === endColumn) {
          if (startColumn) {
            markerLines[startLine] = [startColumn, 0];
          } else {
            markerLines[startLine] = true;
          }
        } else {
          markerLines[startLine] = [startColumn, endColumn - startColumn];
        }
      }
      return {
        start: start3,
        end,
        markerLines
      };
    }
    function codeFrameColumns(rawLines, loc, opts = {}) {
      const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
      const chalk = (0, _highlight.getChalk)(opts);
      const defs = getDefs(chalk);
      const maybeHighlight = (chalkFn, string3) => {
        return highlighted ? chalkFn(string3) : string3;
      };
      const lines = rawLines.split(NEWLINE);
      const {
        start: start3,
        end,
        markerLines
      } = getMarkerLines(loc, lines, opts);
      const hasColumns = loc.start && typeof loc.start.column === "number";
      const numberMaxWidth = String(end).length;
      const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
      let frame = highlightedLines.split(NEWLINE, end).slice(start3, end).map((line2, index2) => {
        const number2 = start3 + 1 + index2;
        const paddedNumber = ` ${number2}`.slice(-numberMaxWidth);
        const gutter = ` ${paddedNumber} |`;
        const hasMarker = markerLines[number2];
        const lastMarkerLine = !markerLines[number2 + 1];
        if (hasMarker) {
          let markerLine = "";
          if (Array.isArray(hasMarker)) {
            const markerSpacing = line2.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
            const numberOfMarkers = hasMarker[1] || 1;
            markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
            if (lastMarkerLine && opts.message) {
              markerLine += " " + maybeHighlight(defs.message, opts.message);
            }
          }
          return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line2.length > 0 ? ` ${line2}` : "", markerLine].join("");
        } else {
          return ` ${maybeHighlight(defs.gutter, gutter)}${line2.length > 0 ? ` ${line2}` : ""}`;
        }
      }).join("\n");
      if (opts.message && !hasColumns) {
        frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}
${frame}`;
      }
      if (highlighted) {
        return chalk.reset(frame);
      } else {
        return frame;
      }
    }
    function _default(rawLines, lineNumber, colNumber, opts = {}) {
      if (!deprecationWarningShown) {
        deprecationWarningShown = true;
        const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
        if (process.emitWarning) {
          process.emitWarning(message, "DeprecationWarning");
        } else {
          const deprecationError = new Error(message);
          deprecationError.name = "DeprecationWarning";
          console.warn(new Error(message));
        }
      }
      colNumber = Math.max(colNumber, 0);
      const location2 = {
        start: {
          column: colNumber,
          line: lineNumber
        }
      };
      return codeFrameColumns(rawLines, location2, opts);
    }
  }
});

// node_modules/@babel/parser/lib/index.js
var require_lib9 = __commonJS({
  "node_modules/@babel/parser/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    var defaultOptions3 = {
      sourceType: "script",
      sourceFilename: void 0,
      startColumn: 0,
      startLine: 1,
      allowAwaitOutsideFunction: false,
      allowReturnOutsideFunction: false,
      allowNewTargetOutsideFunction: false,
      allowImportExportEverywhere: false,
      allowSuperOutsideMethod: false,
      allowUndeclaredExports: false,
      plugins: [],
      strictMode: null,
      ranges: false,
      tokens: false,
      createParenthesizedExpressions: false,
      errorRecovery: false,
      attachComment: true,
      annexB: true
    };
    function getOptions3(opts) {
      if (opts && opts.annexB != null && opts.annexB !== false) {
        throw new Error("The `annexB` option can only be set to `false`.");
      }
      const options = {};
      for (const key2 of Object.keys(defaultOptions3)) {
        options[key2] = opts && opts[key2] != null ? opts[key2] : defaultOptions3[key2];
      }
      return options;
    }
    var TokContext5 = class {
      constructor(token2, preserveSpace) {
        this.token = void 0;
        this.preserveSpace = void 0;
        this.token = token2;
        this.preserveSpace = !!preserveSpace;
      }
    };
    var types3 = {
      brace: new TokContext5("{"),
      j_oTag: new TokContext5("<tag"),
      j_cTag: new TokContext5("</tag"),
      j_expr: new TokContext5("<tag>...</tag>", true)
    };
    {
      types3.template = new TokContext5("`", true);
    }
    var beforeExpr3 = true;
    var startsExpr3 = true;
    var isLoop = true;
    var isAssign = true;
    var prefix = true;
    var postfix = true;
    var ExportedTokenType = class {
      constructor(label, conf = {}) {
        this.label = void 0;
        this.keyword = void 0;
        this.beforeExpr = void 0;
        this.startsExpr = void 0;
        this.rightAssociative = void 0;
        this.isLoop = void 0;
        this.isAssign = void 0;
        this.prefix = void 0;
        this.postfix = void 0;
        this.binop = void 0;
        this.label = label;
        this.keyword = conf.keyword;
        this.beforeExpr = !!conf.beforeExpr;
        this.startsExpr = !!conf.startsExpr;
        this.rightAssociative = !!conf.rightAssociative;
        this.isLoop = !!conf.isLoop;
        this.isAssign = !!conf.isAssign;
        this.prefix = !!conf.prefix;
        this.postfix = !!conf.postfix;
        this.binop = conf.binop != null ? conf.binop : null;
        {
          this.updateContext = null;
        }
      }
    };
    var keywords$13 = /* @__PURE__ */ new Map();
    function createKeyword(name2, options = {}) {
      options.keyword = name2;
      const token2 = createToken(name2, options);
      keywords$13.set(name2, token2);
      return token2;
    }
    function createBinop(name2, binop3) {
      return createToken(name2, {
        beforeExpr: beforeExpr3,
        binop: binop3
      });
    }
    var tokenTypeCounter = -1;
    var tokenTypes = [];
    var tokenLabels = [];
    var tokenBinops = [];
    var tokenBeforeExprs = [];
    var tokenStartsExprs = [];
    var tokenPrefixes = [];
    function createToken(name2, options = {}) {
      var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
      ++tokenTypeCounter;
      tokenLabels.push(name2);
      tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
      tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
      tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
      tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
      tokenTypes.push(new ExportedTokenType(name2, options));
      return tokenTypeCounter;
    }
    function createKeywordLike(name2, options = {}) {
      var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
      ++tokenTypeCounter;
      keywords$13.set(name2, tokenTypeCounter);
      tokenLabels.push(name2);
      tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
      tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
      tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
      tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
      tokenTypes.push(new ExportedTokenType("name", options));
      return tokenTypeCounter;
    }
    var tt = {
      bracketL: createToken("[", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      bracketHashL: createToken("#[", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      bracketBarL: createToken("[|", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      bracketR: createToken("]"),
      bracketBarR: createToken("|]"),
      braceL: createToken("{", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      braceBarL: createToken("{|", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      braceHashL: createToken("#{", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      braceR: createToken("}"),
      braceBarR: createToken("|}"),
      parenL: createToken("(", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      parenR: createToken(")"),
      comma: createToken(",", {
        beforeExpr: beforeExpr3
      }),
      semi: createToken(";", {
        beforeExpr: beforeExpr3
      }),
      colon: createToken(":", {
        beforeExpr: beforeExpr3
      }),
      doubleColon: createToken("::", {
        beforeExpr: beforeExpr3
      }),
      dot: createToken("."),
      question: createToken("?", {
        beforeExpr: beforeExpr3
      }),
      questionDot: createToken("?."),
      arrow: createToken("=>", {
        beforeExpr: beforeExpr3
      }),
      template: createToken("template"),
      ellipsis: createToken("...", {
        beforeExpr: beforeExpr3
      }),
      backQuote: createToken("`", {
        startsExpr: startsExpr3
      }),
      dollarBraceL: createToken("${", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      templateTail: createToken("...`", {
        startsExpr: startsExpr3
      }),
      templateNonTail: createToken("...${", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      at: createToken("@"),
      hash: createToken("#", {
        startsExpr: startsExpr3
      }),
      interpreterDirective: createToken("#!..."),
      eq: createToken("=", {
        beforeExpr: beforeExpr3,
        isAssign
      }),
      assign: createToken("_=", {
        beforeExpr: beforeExpr3,
        isAssign
      }),
      slashAssign: createToken("_=", {
        beforeExpr: beforeExpr3,
        isAssign
      }),
      xorAssign: createToken("_=", {
        beforeExpr: beforeExpr3,
        isAssign
      }),
      moduloAssign: createToken("_=", {
        beforeExpr: beforeExpr3,
        isAssign
      }),
      incDec: createToken("++/--", {
        prefix,
        postfix,
        startsExpr: startsExpr3
      }),
      bang: createToken("!", {
        beforeExpr: beforeExpr3,
        prefix,
        startsExpr: startsExpr3
      }),
      tilde: createToken("~", {
        beforeExpr: beforeExpr3,
        prefix,
        startsExpr: startsExpr3
      }),
      doubleCaret: createToken("^^", {
        startsExpr: startsExpr3
      }),
      doubleAt: createToken("@@", {
        startsExpr: startsExpr3
      }),
      pipeline: createBinop("|>", 0),
      nullishCoalescing: createBinop("??", 1),
      logicalOR: createBinop("||", 1),
      logicalAND: createBinop("&&", 2),
      bitwiseOR: createBinop("|", 3),
      bitwiseXOR: createBinop("^", 4),
      bitwiseAND: createBinop("&", 5),
      equality: createBinop("==/!=/===/!==", 6),
      lt: createBinop("</>/<=/>=", 7),
      gt: createBinop("</>/<=/>=", 7),
      relational: createBinop("</>/<=/>=", 7),
      bitShift: createBinop("<</>>/>>>", 8),
      bitShiftL: createBinop("<</>>/>>>", 8),
      bitShiftR: createBinop("<</>>/>>>", 8),
      plusMin: createToken("+/-", {
        beforeExpr: beforeExpr3,
        binop: 9,
        prefix,
        startsExpr: startsExpr3
      }),
      modulo: createToken("%", {
        binop: 10,
        startsExpr: startsExpr3
      }),
      star: createToken("*", {
        binop: 10
      }),
      slash: createBinop("/", 10),
      exponent: createToken("**", {
        beforeExpr: beforeExpr3,
        binop: 11,
        rightAssociative: true
      }),
      _in: createKeyword("in", {
        beforeExpr: beforeExpr3,
        binop: 7
      }),
      _instanceof: createKeyword("instanceof", {
        beforeExpr: beforeExpr3,
        binop: 7
      }),
      _break: createKeyword("break"),
      _case: createKeyword("case", {
        beforeExpr: beforeExpr3
      }),
      _catch: createKeyword("catch"),
      _continue: createKeyword("continue"),
      _debugger: createKeyword("debugger"),
      _default: createKeyword("default", {
        beforeExpr: beforeExpr3
      }),
      _else: createKeyword("else", {
        beforeExpr: beforeExpr3
      }),
      _finally: createKeyword("finally"),
      _function: createKeyword("function", {
        startsExpr: startsExpr3
      }),
      _if: createKeyword("if"),
      _return: createKeyword("return", {
        beforeExpr: beforeExpr3
      }),
      _switch: createKeyword("switch"),
      _throw: createKeyword("throw", {
        beforeExpr: beforeExpr3,
        prefix,
        startsExpr: startsExpr3
      }),
      _try: createKeyword("try"),
      _var: createKeyword("var"),
      _const: createKeyword("const"),
      _with: createKeyword("with"),
      _new: createKeyword("new", {
        beforeExpr: beforeExpr3,
        startsExpr: startsExpr3
      }),
      _this: createKeyword("this", {
        startsExpr: startsExpr3
      }),
      _super: createKeyword("super", {
        startsExpr: startsExpr3
      }),
      _class: createKeyword("class", {
        startsExpr: startsExpr3
      }),
      _extends: createKeyword("extends", {
        beforeExpr: beforeExpr3
      }),
      _export: createKeyword("export"),
      _import: createKeyword("import", {
        startsExpr: startsExpr3
      }),
      _null: createKeyword("null", {
        startsExpr: startsExpr3
      }),
      _true: createKeyword("true", {
        startsExpr: startsExpr3
      }),
      _false: createKeyword("false", {
        startsExpr: startsExpr3
      }),
      _typeof: createKeyword("typeof", {
        beforeExpr: beforeExpr3,
        prefix,
        startsExpr: startsExpr3
      }),
      _void: createKeyword("void", {
        beforeExpr: beforeExpr3,
        prefix,
        startsExpr: startsExpr3
      }),
      _delete: createKeyword("delete", {
        beforeExpr: beforeExpr3,
        prefix,
        startsExpr: startsExpr3
      }),
      _do: createKeyword("do", {
        isLoop,
        beforeExpr: beforeExpr3
      }),
      _for: createKeyword("for", {
        isLoop
      }),
      _while: createKeyword("while", {
        isLoop
      }),
      _as: createKeywordLike("as", {
        startsExpr: startsExpr3
      }),
      _assert: createKeywordLike("assert", {
        startsExpr: startsExpr3
      }),
      _async: createKeywordLike("async", {
        startsExpr: startsExpr3
      }),
      _await: createKeywordLike("await", {
        startsExpr: startsExpr3
      }),
      _from: createKeywordLike("from", {
        startsExpr: startsExpr3
      }),
      _get: createKeywordLike("get", {
        startsExpr: startsExpr3
      }),
      _let: createKeywordLike("let", {
        startsExpr: startsExpr3
      }),
      _meta: createKeywordLike("meta", {
        startsExpr: startsExpr3
      }),
      _of: createKeywordLike("of", {
        startsExpr: startsExpr3
      }),
      _sent: createKeywordLike("sent", {
        startsExpr: startsExpr3
      }),
      _set: createKeywordLike("set", {
        startsExpr: startsExpr3
      }),
      _static: createKeywordLike("static", {
        startsExpr: startsExpr3
      }),
      _using: createKeywordLike("using", {
        startsExpr: startsExpr3
      }),
      _yield: createKeywordLike("yield", {
        startsExpr: startsExpr3
      }),
      _asserts: createKeywordLike("asserts", {
        startsExpr: startsExpr3
      }),
      _checks: createKeywordLike("checks", {
        startsExpr: startsExpr3
      }),
      _exports: createKeywordLike("exports", {
        startsExpr: startsExpr3
      }),
      _global: createKeywordLike("global", {
        startsExpr: startsExpr3
      }),
      _implements: createKeywordLike("implements", {
        startsExpr: startsExpr3
      }),
      _intrinsic: createKeywordLike("intrinsic", {
        startsExpr: startsExpr3
      }),
      _infer: createKeywordLike("infer", {
        startsExpr: startsExpr3
      }),
      _is: createKeywordLike("is", {
        startsExpr: startsExpr3
      }),
      _mixins: createKeywordLike("mixins", {
        startsExpr: startsExpr3
      }),
      _proto: createKeywordLike("proto", {
        startsExpr: startsExpr3
      }),
      _require: createKeywordLike("require", {
        startsExpr: startsExpr3
      }),
      _satisfies: createKeywordLike("satisfies", {
        startsExpr: startsExpr3
      }),
      _keyof: createKeywordLike("keyof", {
        startsExpr: startsExpr3
      }),
      _readonly: createKeywordLike("readonly", {
        startsExpr: startsExpr3
      }),
      _unique: createKeywordLike("unique", {
        startsExpr: startsExpr3
      }),
      _abstract: createKeywordLike("abstract", {
        startsExpr: startsExpr3
      }),
      _declare: createKeywordLike("declare", {
        startsExpr: startsExpr3
      }),
      _enum: createKeywordLike("enum", {
        startsExpr: startsExpr3
      }),
      _module: createKeywordLike("module", {
        startsExpr: startsExpr3
      }),
      _namespace: createKeywordLike("namespace", {
        startsExpr: startsExpr3
      }),
      _interface: createKeywordLike("interface", {
        startsExpr: startsExpr3
      }),
      _type: createKeywordLike("type", {
        startsExpr: startsExpr3
      }),
      _opaque: createKeywordLike("opaque", {
        startsExpr: startsExpr3
      }),
      name: createToken("name", {
        startsExpr: startsExpr3
      }),
      string: createToken("string", {
        startsExpr: startsExpr3
      }),
      num: createToken("num", {
        startsExpr: startsExpr3
      }),
      bigint: createToken("bigint", {
        startsExpr: startsExpr3
      }),
      decimal: createToken("decimal", {
        startsExpr: startsExpr3
      }),
      regexp: createToken("regexp", {
        startsExpr: startsExpr3
      }),
      privateName: createToken("#name", {
        startsExpr: startsExpr3
      }),
      eof: createToken("eof"),
      jsxName: createToken("jsxName"),
      jsxText: createToken("jsxText", {
        beforeExpr: true
      }),
      jsxTagStart: createToken("jsxTagStart", {
        startsExpr: true
      }),
      jsxTagEnd: createToken("jsxTagEnd"),
      placeholder: createToken("%%", {
        startsExpr: true
      })
    };
    function tokenIsIdentifier(token2) {
      return token2 >= 93 && token2 <= 130;
    }
    function tokenKeywordOrIdentifierIsKeyword(token2) {
      return token2 <= 92;
    }
    function tokenIsKeywordOrIdentifier(token2) {
      return token2 >= 58 && token2 <= 130;
    }
    function tokenIsLiteralPropertyName(token2) {
      return token2 >= 58 && token2 <= 134;
    }
    function tokenComesBeforeExpression(token2) {
      return tokenBeforeExprs[token2];
    }
    function tokenCanStartExpression(token2) {
      return tokenStartsExprs[token2];
    }
    function tokenIsAssignment(token2) {
      return token2 >= 29 && token2 <= 33;
    }
    function tokenIsFlowInterfaceOrTypeOrOpaque(token2) {
      return token2 >= 127 && token2 <= 129;
    }
    function tokenIsLoop(token2) {
      return token2 >= 90 && token2 <= 92;
    }
    function tokenIsKeyword(token2) {
      return token2 >= 58 && token2 <= 92;
    }
    function tokenIsOperator(token2) {
      return token2 >= 39 && token2 <= 59;
    }
    function tokenIsPostfix(token2) {
      return token2 === 34;
    }
    function tokenIsPrefix(token2) {
      return tokenPrefixes[token2];
    }
    function tokenIsTSTypeOperator(token2) {
      return token2 >= 119 && token2 <= 121;
    }
    function tokenIsTSDeclarationStart(token2) {
      return token2 >= 122 && token2 <= 128;
    }
    function tokenLabelName(token2) {
      return tokenLabels[token2];
    }
    function tokenOperatorPrecedence(token2) {
      return tokenBinops[token2];
    }
    function tokenIsRightAssociative(token2) {
      return token2 === 57;
    }
    function tokenIsTemplate(token2) {
      return token2 >= 24 && token2 <= 25;
    }
    function getExportedToken(token2) {
      return tokenTypes[token2];
    }
    {
      tokenTypes[8].updateContext = (context) => {
        context.pop();
      };
      tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
        context.push(types3.brace);
      };
      tokenTypes[22].updateContext = (context) => {
        if (context[context.length - 1] === types3.template) {
          context.pop();
        } else {
          context.push(types3.template);
        }
      };
      tokenTypes[140].updateContext = (context) => {
        context.push(types3.j_expr, types3.j_oTag);
      };
    }
    function _objectWithoutPropertiesLoose(source2, excluded) {
      if (source2 == null)
        return {};
      var target = {};
      var sourceKeys = Object.keys(source2);
      var key2, i;
      for (i = 0; i < sourceKeys.length; i++) {
        key2 = sourceKeys[i];
        if (excluded.indexOf(key2) >= 0)
          continue;
        target[key2] = source2[key2];
      }
      return target;
    }
    var Position5 = class {
      constructor(line2, col, index2) {
        this.line = void 0;
        this.column = void 0;
        this.index = void 0;
        this.line = line2;
        this.column = col;
        this.index = index2;
      }
    };
    var SourceLocation5 = class {
      constructor(start3, end) {
        this.start = void 0;
        this.end = void 0;
        this.filename = void 0;
        this.identifierName = void 0;
        this.start = start3;
        this.end = end;
      }
    };
    function createPositionWithColumnOffset(position3, columnOffset) {
      const {
        line: line2,
        column: column2,
        index: index2
      } = position3;
      return new Position5(line2, column2 + columnOffset, index2 + columnOffset);
    }
    var ParseErrorCode = {
      SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
      SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
    };
    var reflect = (keys2, last = keys2.length - 1) => ({
      get() {
        return keys2.reduce((object, key2) => object[key2], this);
      },
      set(value2) {
        keys2.reduce((item, key2, i) => i === last ? item[key2] = value2 : item[key2], this);
      }
    });
    var instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map((key2) => [key2, descriptors[key2]]).filter(([, descriptor]) => !!descriptor).map(([key2, descriptor]) => [key2, typeof descriptor === "function" ? {
      value: descriptor,
      enumerable: false
    } : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key2, descriptor]) => Object.defineProperty(instance, key2, Object.assign({
      configurable: true
    }, descriptor)), Object.assign(new constructor(), properties));
    var ModuleErrors = {
      ImportMetaOutsideModule: {
        message: `import.meta may appear only with 'sourceType: "module"'`,
        code: ParseErrorCode.SourceTypeModuleError
      },
      ImportOutsideModule: {
        message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
        code: ParseErrorCode.SourceTypeModuleError
      }
    };
    var NodeDescriptions = {
      ArrayPattern: "array destructuring pattern",
      AssignmentExpression: "assignment expression",
      AssignmentPattern: "assignment expression",
      ArrowFunctionExpression: "arrow function expression",
      ConditionalExpression: "conditional expression",
      CatchClause: "catch clause",
      ForOfStatement: "for-of statement",
      ForInStatement: "for-in statement",
      ForStatement: "for-loop",
      FormalParameters: "function parameter list",
      Identifier: "identifier",
      ImportSpecifier: "import specifier",
      ImportDefaultSpecifier: "import default specifier",
      ImportNamespaceSpecifier: "import namespace specifier",
      ObjectPattern: "object destructuring pattern",
      ParenthesizedExpression: "parenthesized expression",
      RestElement: "rest element",
      UpdateExpression: {
        true: "prefix operation",
        false: "postfix operation"
      },
      VariableDeclarator: "variable declaration",
      YieldExpression: "yield expression"
    };
    var toNodeDescription = ({
      type,
      prefix: prefix2
    }) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix2)] : NodeDescriptions[type];
    var StandardErrors = {
      AccessorIsGenerator: ({
        kind
      }) => `A ${kind}ter cannot be a generator.`,
      ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
      AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
      AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
      AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
      AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
      AwaitInUsingBinding: "'await' is not allowed to be used as a name in 'using' declarations.",
      AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
      AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
      BadGetterArity: "A 'get' accessor must not have any formal parameters.",
      BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
      BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
      ConstructorClassField: "Classes may not have a field named 'constructor'.",
      ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
      ConstructorIsAccessor: "Class constructor may not be an accessor.",
      ConstructorIsAsync: "Constructor can't be an async function.",
      ConstructorIsGenerator: "Constructor can't be a generator.",
      DeclarationMissingInitializer: ({
        kind
      }) => `Missing initializer in ${kind} declaration.`,
      DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
      DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
      DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
      DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
      DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
      DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
      DecoratorStaticBlock: "Decorators can't be used with a static block.",
      DeletePrivateField: "Deleting a private field is not allowed.",
      DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
      DuplicateConstructor: "Duplicate constructor in the same class.",
      DuplicateDefaultExport: "Only one default export allowed per module.",
      DuplicateExport: ({
        exportName
      }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
      DuplicateProto: "Redefinition of __proto__ property.",
      DuplicateRegExpFlags: "Duplicate regular expression flag.",
      ElementAfterRest: "Rest element must be last element.",
      EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
      ExportBindingIsString: ({
        localName,
        exportName
      }) => `A string literal cannot be used as an exported binding without \`from\`.
- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
      ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
      ForInOfLoopInitializer: ({
        type
      }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
      ForInUsing: "For-in loop may not start with 'using' declaration.",
      ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
      ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
      GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
      IllegalBreakContinue: ({
        type
      }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
      IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
      IllegalReturn: "'return' outside of function.",
      ImportBindingIsString: ({
        importName
      }) => `A string literal cannot be used as an imported binding.
- Did you mean \`import { "${importName}" as foo }\`?`,
      ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.",
      ImportCallArity: ({
        maxArgumentCount
      }) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`,
      ImportCallNotNewExpression: "Cannot use new with import(...).",
      ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
      ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
      ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
      ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
      IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
      InvalidBigIntLiteral: "Invalid BigIntLiteral.",
      InvalidCodePoint: "Code point out of bounds.",
      InvalidCoverInitializedName: "Invalid shorthand property initializer.",
      InvalidDecimal: "Invalid decimal.",
      InvalidDigit: ({
        radix
      }) => `Expected number in radix ${radix}.`,
      InvalidEscapeSequence: "Bad character escape sequence.",
      InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
      InvalidEscapedReservedWord: ({
        reservedWord
      }) => `Escape sequence in keyword ${reservedWord}.`,
      InvalidIdentifier: ({
        identifierName
      }) => `Invalid identifier ${identifierName}.`,
      InvalidLhs: ({
        ancestor
      }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
      InvalidLhsBinding: ({
        ancestor
      }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
      InvalidNumber: "Invalid number.",
      InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
      InvalidOrUnexpectedToken: ({
        unexpected
      }) => `Unexpected character '${unexpected}'.`,
      InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
      InvalidPrivateFieldResolution: ({
        identifierName
      }) => `Private name #${identifierName} is not defined.`,
      InvalidPropertyBindingPattern: "Binding member expression.",
      InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.",
      InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
      LabelRedeclaration: ({
        labelName
      }) => `Label '${labelName}' is already declared.`,
      LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations.",
      LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
      MalformedRegExpFlags: "Invalid regular expression flag.",
      MissingClassName: "A class name is required.",
      MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
      MissingSemicolon: "Missing semicolon.",
      MissingPlugin: ({
        missingPlugin
      }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map((name2) => JSON.stringify(name2)).join(", ")}.`,
      MissingOneOfPlugins: ({
        missingPlugin
      }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map((name2) => JSON.stringify(name2)).join(", ")}.`,
      MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
      MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
      ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.",
      ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
      ModuleAttributesWithDuplicateKeys: ({
        key: key2
      }) => `Duplicate key "${key2}" is not allowed in module attributes.`,
      ModuleExportNameHasLoneSurrogate: ({
        surrogateCharCode
      }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
      ModuleExportUndefined: ({
        localName
      }) => `Export '${localName}' is not defined.`,
      MultipleDefaultsInSwitch: "Multiple default clauses.",
      NewlineAfterThrow: "Illegal newline after throw.",
      NoCatchOrFinally: "Missing catch or finally clause.",
      NumberIdentifier: "Identifier directly after number.",
      NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
      ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
      OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
      OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
      OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
      ParamDupe: "Argument name clash.",
      PatternHasAccessor: "Object pattern can't contain getter or setter.",
      PatternHasMethod: "Object pattern can't contain methods.",
      PrivateInExpectedIn: ({
        identifierName
      }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
      PrivateNameRedeclaration: ({
        identifierName
      }) => `Duplicate private name #${identifierName}.`,
      RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
      RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
      RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
      RecordNoProto: "'__proto__' is not allowed in Record expressions.",
      RestTrailingComma: "Unexpected trailing comma after rest element.",
      SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
      SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
      StaticPrototype: "Classes may not have static property named prototype.",
      SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
      SuperPrivateField: "Private fields can't be accessed on super.",
      TrailingDecorator: "Decorators must be attached to a class element.",
      TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
      TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
      TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
      UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
      UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.',
      UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
      UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
      UnexpectedKeyword: ({
        keyword
      }) => `Unexpected keyword '${keyword}'.`,
      UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
      UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
      UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
      UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
      UnexpectedPrivateField: "Unexpected private name.",
      UnexpectedReservedWord: ({
        reservedWord
      }) => `Unexpected reserved word '${reservedWord}'.`,
      UnexpectedSuper: "'super' is only allowed in object methods and classes.",
      UnexpectedToken: ({
        expected,
        unexpected
      }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
      UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
      UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
      UnsupportedBind: "Binding should be performed on object property.",
      UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
      UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
      UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
      UnsupportedMetaProperty: ({
        target,
        onlyValidPropertyName
      }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
      UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
      UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
      UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
      UnterminatedComment: "Unterminated comment.",
      UnterminatedRegExp: "Unterminated regular expression.",
      UnterminatedString: "Unterminated string constant.",
      UnterminatedTemplate: "Unterminated template.",
      UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
      VarRedeclaration: ({
        identifierName
      }) => `Identifier '${identifierName}' has already been declared.`,
      YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
      YieldInParameter: "Yield expression is not allowed in formal parameters.",
      ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
    };
    var StrictModeErrors = {
      StrictDelete: "Deleting local variable in strict mode.",
      StrictEvalArguments: ({
        referenceName
      }) => `Assigning to '${referenceName}' in strict mode.`,
      StrictEvalArgumentsBinding: ({
        bindingName
      }) => `Binding '${bindingName}' in strict mode.`,
      StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
      StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
      StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
      StrictWith: "'with' in strict mode."
    };
    var UnparenthesizedPipeBodyDescriptions = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
    var PipelineOperatorErrors = {
      PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
      PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
      PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
      PipeTopicUnconfiguredToken: ({
        token: token2
      }) => `Invalid topic token ${token2}. In order to use ${token2} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token2}" }.`,
      PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
      PipeUnparenthesizedBody: ({
        type
      }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({
        type
      })}; please wrap it in parentheses.`,
      PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
      PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
      PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
      PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
      PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
      PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
    };
    var _excluded$1 = ["toMessage"];
    var _excluded2$1 = ["message"];
    function toParseErrorConstructor(_ref) {
      let {
        toMessage
      } = _ref, properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
      return function constructor({
        loc,
        details
      }) {
        return instantiate(SyntaxError, Object.assign({}, properties, {
          loc
        }), {
          clone(overrides = {}) {
            const loc2 = overrides.loc || {};
            return constructor({
              loc: new Position5("line" in loc2 ? loc2.line : this.loc.line, "column" in loc2 ? loc2.column : this.loc.column, "index" in loc2 ? loc2.index : this.loc.index),
              details: Object.assign({}, this.details, overrides.details)
            });
          },
          details: {
            value: details,
            enumerable: false
          },
          message: {
            get() {
              return `${toMessage(this.details)} (${this.loc.line}:${this.loc.column})`;
            },
            set(value2) {
              Object.defineProperty(this, "message", {
                value: value2
              });
            }
          },
          pos: {
            reflect: "loc.index",
            enumerable: true
          },
          missingPlugin: "missingPlugin" in details && {
            reflect: "details.missingPlugin",
            enumerable: true
          }
        });
      };
    }
    function ParseErrorEnum(argument, syntaxPlugin) {
      if (Array.isArray(argument)) {
        return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
      }
      const ParseErrorConstructors = {};
      for (const reasonCode of Object.keys(argument)) {
        const template = argument[reasonCode];
        const _ref2 = typeof template === "string" ? {
          message: () => template
        } : typeof template === "function" ? {
          message: template
        } : template, {
          message
        } = _ref2, rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
        const toMessage = typeof message === "string" ? () => message : message;
        ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
          code: ParseErrorCode.SyntaxError,
          reasonCode,
          toMessage
        }, syntaxPlugin ? {
          syntaxPlugin
        } : {}, rest));
      }
      return ParseErrorConstructors;
    }
    var Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
    var {
      defineProperty
    } = Object;
    var toUnenumerable = (object, key2) => defineProperty(object, key2, {
      enumerable: false,
      value: object[key2]
    });
    function toESTreeLocation(node2) {
      node2.loc.start && toUnenumerable(node2.loc.start, "index");
      node2.loc.end && toUnenumerable(node2.loc.end, "index");
      return node2;
    }
    var estree = (superClass) => class ESTreeParserMixin extends superClass {
      parse() {
        const file = toESTreeLocation(super.parse());
        if (this.options.tokens) {
          file.tokens = file.tokens.map(toESTreeLocation);
        }
        return file;
      }
      parseRegExpLiteral({
        pattern,
        flags
      }) {
        let regex2 = null;
        try {
          regex2 = new RegExp(pattern, flags);
        } catch (e) {
        }
        const node2 = this.estreeParseLiteral(regex2);
        node2.regex = {
          pattern,
          flags
        };
        return node2;
      }
      parseBigIntLiteral(value2) {
        let bigInt;
        try {
          bigInt = BigInt(value2);
        } catch (_unused) {
          bigInt = null;
        }
        const node2 = this.estreeParseLiteral(bigInt);
        node2.bigint = String(node2.value || value2);
        return node2;
      }
      parseDecimalLiteral(value2) {
        const decimal = null;
        const node2 = this.estreeParseLiteral(decimal);
        node2.decimal = String(node2.value || value2);
        return node2;
      }
      estreeParseLiteral(value2) {
        return this.parseLiteral(value2, "Literal");
      }
      parseStringLiteral(value2) {
        return this.estreeParseLiteral(value2);
      }
      parseNumericLiteral(value2) {
        return this.estreeParseLiteral(value2);
      }
      parseNullLiteral() {
        return this.estreeParseLiteral(null);
      }
      parseBooleanLiteral(value2) {
        return this.estreeParseLiteral(value2);
      }
      directiveToStmt(directive) {
        const expression = directive.value;
        delete directive.value;
        expression.type = "Literal";
        expression.raw = expression.extra.raw;
        expression.value = expression.extra.expressionValue;
        const stmt = directive;
        stmt.type = "ExpressionStatement";
        stmt.expression = expression;
        stmt.directive = expression.extra.rawValue;
        delete expression.extra;
        return stmt;
      }
      initFunction(node2, isAsync) {
        super.initFunction(node2, isAsync);
        node2.expression = false;
      }
      checkDeclaration(node2) {
        if (node2 != null && this.isObjectProperty(node2)) {
          this.checkDeclaration(node2.value);
        } else {
          super.checkDeclaration(node2);
        }
      }
      getObjectOrClassMethodParams(method) {
        return method.value.params;
      }
      isValidDirective(stmt) {
        var _stmt$expression$extr;
        return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);
      }
      parseBlockBody(node2, allowDirectives, topLevel, end, afterBlockParse) {
        super.parseBlockBody(node2, allowDirectives, topLevel, end, afterBlockParse);
        const directiveStatements = node2.directives.map((d) => this.directiveToStmt(d));
        node2.body = directiveStatements.concat(node2.body);
        delete node2.directives;
      }
      pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
        this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
        if (method.typeParameters) {
          method.value.typeParameters = method.typeParameters;
          delete method.typeParameters;
        }
        classBody.body.push(method);
      }
      parsePrivateName() {
        const node2 = super.parsePrivateName();
        {
          if (!this.getPluginOption("estree", "classFeatures")) {
            return node2;
          }
        }
        return this.convertPrivateNameToPrivateIdentifier(node2);
      }
      convertPrivateNameToPrivateIdentifier(node2) {
        const name2 = super.getPrivateNameSV(node2);
        node2 = node2;
        delete node2.id;
        node2.name = name2;
        node2.type = "PrivateIdentifier";
        return node2;
      }
      isPrivateName(node2) {
        {
          if (!this.getPluginOption("estree", "classFeatures")) {
            return super.isPrivateName(node2);
          }
        }
        return node2.type === "PrivateIdentifier";
      }
      getPrivateNameSV(node2) {
        {
          if (!this.getPluginOption("estree", "classFeatures")) {
            return super.getPrivateNameSV(node2);
          }
        }
        return node2.name;
      }
      parseLiteral(value2, type) {
        const node2 = super.parseLiteral(value2, type);
        node2.raw = node2.extra.raw;
        delete node2.extra;
        return node2;
      }
      parseFunctionBody(node2, allowExpression, isMethod = false) {
        super.parseFunctionBody(node2, allowExpression, isMethod);
        node2.expression = node2.body.type !== "BlockStatement";
      }
      parseMethod(node2, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
        let funcNode = this.startNode();
        funcNode.kind = node2.kind;
        funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
        funcNode.type = "FunctionExpression";
        delete funcNode.kind;
        node2.value = funcNode;
        if (type === "ClassPrivateMethod") {
          node2.computed = false;
        }
        return this.finishNode(node2, "MethodDefinition");
      }
      parseClassProperty(...args) {
        const propertyNode = super.parseClassProperty(...args);
        {
          if (!this.getPluginOption("estree", "classFeatures")) {
            return propertyNode;
          }
        }
        propertyNode.type = "PropertyDefinition";
        return propertyNode;
      }
      parseClassPrivateProperty(...args) {
        const propertyNode = super.parseClassPrivateProperty(...args);
        {
          if (!this.getPluginOption("estree", "classFeatures")) {
            return propertyNode;
          }
        }
        propertyNode.type = "PropertyDefinition";
        propertyNode.computed = false;
        return propertyNode;
      }
      parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
        const node2 = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor);
        if (node2) {
          node2.type = "Property";
          if (node2.kind === "method") {
            node2.kind = "init";
          }
          node2.shorthand = false;
        }
        return node2;
      }
      parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
        const node2 = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
        if (node2) {
          node2.kind = "init";
          node2.type = "Property";
        }
        return node2;
      }
      isValidLVal(type, isUnparenthesizedInAssign, binding) {
        return type === "Property" ? "value" : super.isValidLVal(type, isUnparenthesizedInAssign, binding);
      }
      isAssignable(node2, isBinding) {
        if (node2 != null && this.isObjectProperty(node2)) {
          return this.isAssignable(node2.value, isBinding);
        }
        return super.isAssignable(node2, isBinding);
      }
      toAssignable(node2, isLHS = false) {
        if (node2 != null && this.isObjectProperty(node2)) {
          const {
            key: key2,
            value: value2
          } = node2;
          if (this.isPrivateName(key2)) {
            this.classScope.usePrivateName(this.getPrivateNameSV(key2), key2.loc.start);
          }
          this.toAssignable(value2, isLHS);
        } else {
          super.toAssignable(node2, isLHS);
        }
      }
      toAssignableObjectExpressionProp(prop, isLast, isLHS) {
        if (prop.kind === "get" || prop.kind === "set") {
          this.raise(Errors.PatternHasAccessor, {
            at: prop.key
          });
        } else if (prop.method) {
          this.raise(Errors.PatternHasMethod, {
            at: prop.key
          });
        } else {
          super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
        }
      }
      finishCallExpression(unfinished, optional) {
        const node2 = super.finishCallExpression(unfinished, optional);
        if (node2.callee.type === "Import") {
          node2.type = "ImportExpression";
          node2.source = node2.arguments[0];
          if (this.hasPlugin("importAssertions")) {
            var _node$arguments$;
            node2.attributes = (_node$arguments$ = node2.arguments[1]) != null ? _node$arguments$ : null;
          }
          delete node2.arguments;
          delete node2.callee;
        }
        return node2;
      }
      toReferencedArguments(node2) {
        if (node2.type === "ImportExpression") {
          return;
        }
        super.toReferencedArguments(node2);
      }
      parseExport(unfinished, decorators) {
        const exportStartLoc = this.state.lastTokStartLoc;
        const node2 = super.parseExport(unfinished, decorators);
        switch (node2.type) {
          case "ExportAllDeclaration":
            node2.exported = null;
            break;
          case "ExportNamedDeclaration":
            if (node2.specifiers.length === 1 && node2.specifiers[0].type === "ExportNamespaceSpecifier") {
              node2.type = "ExportAllDeclaration";
              node2.exported = node2.specifiers[0].exported;
              delete node2.specifiers;
            }
          case "ExportDefaultDeclaration":
            {
              var _declaration$decorato;
              const {
                declaration
              } = node2;
              if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node2.start) {
                this.resetStartLocation(node2, exportStartLoc);
              }
            }
            break;
        }
        return node2;
      }
      parseSubscript(base2, startLoc, noCalls, state) {
        const node2 = super.parseSubscript(base2, startLoc, noCalls, state);
        if (state.optionalChainMember) {
          if (node2.type === "OptionalMemberExpression" || node2.type === "OptionalCallExpression") {
            node2.type = node2.type.substring(8);
          }
          if (state.stop) {
            const chain = this.startNodeAtNode(node2);
            chain.expression = node2;
            return this.finishNode(chain, "ChainExpression");
          }
        } else if (node2.type === "MemberExpression" || node2.type === "CallExpression") {
          node2.optional = false;
        }
        return node2;
      }
      hasPropertyAsPrivateName(node2) {
        if (node2.type === "ChainExpression") {
          node2 = node2.expression;
        }
        return super.hasPropertyAsPrivateName(node2);
      }
      isObjectProperty(node2) {
        return node2.type === "Property" && node2.kind === "init" && !node2.method;
      }
      isObjectMethod(node2) {
        return node2.method || node2.kind === "get" || node2.kind === "set";
      }
      finishNodeAt(node2, type, endLoc) {
        return toESTreeLocation(super.finishNodeAt(node2, type, endLoc));
      }
      resetStartLocation(node2, startLoc) {
        super.resetStartLocation(node2, startLoc);
        toESTreeLocation(node2);
      }
      resetEndLocation(node2, endLoc = this.state.lastTokEndLoc) {
        super.resetEndLocation(node2, endLoc);
        toESTreeLocation(node2);
      }
    };
    var nonASCIIidentifierStartChars3 = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
    var nonASCIIidentifierChars3 = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
    var nonASCIIidentifierStart3 = new RegExp("[" + nonASCIIidentifierStartChars3 + "]");
    var nonASCIIidentifier3 = new RegExp("[" + nonASCIIidentifierStartChars3 + nonASCIIidentifierChars3 + "]");
    nonASCIIidentifierStartChars3 = nonASCIIidentifierChars3 = null;
    var astralIdentifierStartCodes3 = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191];
    var astralIdentifierCodes3 = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
    function isInAstralSet3(code2, set) {
      let pos2 = 65536;
      for (let i = 0, length = set.length; i < length; i += 2) {
        pos2 += set[i];
        if (pos2 > code2)
          return false;
        pos2 += set[i + 1];
        if (pos2 >= code2)
          return true;
      }
      return false;
    }
    function isIdentifierStart3(code2) {
      if (code2 < 65)
        return code2 === 36;
      if (code2 <= 90)
        return true;
      if (code2 < 97)
        return code2 === 95;
      if (code2 <= 122)
        return true;
      if (code2 <= 65535) {
        return code2 >= 170 && nonASCIIidentifierStart3.test(String.fromCharCode(code2));
      }
      return isInAstralSet3(code2, astralIdentifierStartCodes3);
    }
    function isIdentifierChar3(code2) {
      if (code2 < 48)
        return code2 === 36;
      if (code2 < 58)
        return true;
      if (code2 < 65)
        return false;
      if (code2 <= 90)
        return true;
      if (code2 < 97)
        return code2 === 95;
      if (code2 <= 122)
        return true;
      if (code2 <= 65535) {
        return code2 >= 170 && nonASCIIidentifier3.test(String.fromCharCode(code2));
      }
      return isInAstralSet3(code2, astralIdentifierStartCodes3) || isInAstralSet3(code2, astralIdentifierCodes3);
    }
    var reservedWords3 = {
      keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
      strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
      strictBind: ["eval", "arguments"]
    };
    var keywords3 = new Set(reservedWords3.keyword);
    var reservedWordsStrictSet = new Set(reservedWords3.strict);
    var reservedWordsStrictBindSet = new Set(reservedWords3.strictBind);
    function isReservedWord(word, inModule) {
      return inModule && word === "await" || word === "enum";
    }
    function isStrictReservedWord(word, inModule) {
      return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
    }
    function isStrictBindOnlyReservedWord(word) {
      return reservedWordsStrictBindSet.has(word);
    }
    function isStrictBindReservedWord(word, inModule) {
      return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
    }
    function isKeyword(word) {
      return keywords3.has(word);
    }
    function isIteratorStart(current3, next, next2) {
      return current3 === 64 && next === 64 && isIdentifierStart3(next2);
    }
    var reservedWordLikeSet = /* @__PURE__ */ new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]);
    function canBeReservedWord(word) {
      return reservedWordLikeSet.has(word);
    }
    var SCOPE_OTHER = 0;
    var SCOPE_PROGRAM = 1;
    var SCOPE_FUNCTION3 = 2;
    var SCOPE_ARROW3 = 4;
    var SCOPE_SIMPLE_CATCH3 = 8;
    var SCOPE_SUPER3 = 16;
    var SCOPE_DIRECT_SUPER3 = 32;
    var SCOPE_CLASS = 64;
    var SCOPE_STATIC_BLOCK = 128;
    var SCOPE_TS_MODULE = 256;
    var SCOPE_VAR3 = SCOPE_PROGRAM | SCOPE_FUNCTION3 | SCOPE_STATIC_BLOCK | SCOPE_TS_MODULE;
    var BIND_KIND_VALUE = 1;
    var BIND_KIND_TYPE = 2;
    var BIND_SCOPE_VAR = 4;
    var BIND_SCOPE_LEXICAL = 8;
    var BIND_SCOPE_FUNCTION = 16;
    var BIND_FLAGS_NONE = 64;
    var BIND_FLAGS_CLASS = 128;
    var BIND_FLAGS_TS_ENUM = 256;
    var BIND_FLAGS_TS_CONST_ENUM = 512;
    var BIND_FLAGS_TS_EXPORT_ONLY = 1024;
    var BIND_FLAGS_FLOW_DECLARE_FN = 2048;
    var BIND_FLAGS_TS_IMPORT = 4096;
    var BIND_FLAGS_NO_LET_IN_LEXICAL = 8192;
    var BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS | BIND_FLAGS_NO_LET_IN_LEXICAL;
    var BIND_LEXICAL3 = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | BIND_FLAGS_NO_LET_IN_LEXICAL;
    var BIND_CATCH_PARAM = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0;
    var BIND_VAR3 = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0;
    var BIND_FUNCTION3 = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0;
    var BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS;
    var BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0;
    var BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM | BIND_FLAGS_NO_LET_IN_LEXICAL;
    var BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY;
    var BIND_NONE3 = 0 | 0 | 0 | BIND_FLAGS_NONE;
    var BIND_OUTSIDE3 = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE;
    var BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM;
    var BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY;
    var BIND_TS_TYPE_IMPORT = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_TS_IMPORT;
    var BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN;
    var CLASS_ELEMENT_FLAG_STATIC = 4;
    var CLASS_ELEMENT_KIND_GETTER = 2;
    var CLASS_ELEMENT_KIND_SETTER = 1;
    var CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;
    var CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC;
    var CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC;
    var CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER;
    var CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER;
    var CLASS_ELEMENT_OTHER = 0;
    var Scope6 = class {
      constructor(flags) {
        this.var = /* @__PURE__ */ new Set();
        this.lexical = /* @__PURE__ */ new Set();
        this.functions = /* @__PURE__ */ new Set();
        this.flags = flags;
      }
    };
    var ScopeHandler = class {
      constructor(parser, inModule) {
        this.parser = void 0;
        this.scopeStack = [];
        this.inModule = void 0;
        this.undefinedExports = /* @__PURE__ */ new Map();
        this.parser = parser;
        this.inModule = inModule;
      }
      get inTopLevel() {
        return (this.currentScope().flags & SCOPE_PROGRAM) > 0;
      }
      get inFunction() {
        return (this.currentVarScopeFlags() & SCOPE_FUNCTION3) > 0;
      }
      get allowSuper() {
        return (this.currentThisScopeFlags() & SCOPE_SUPER3) > 0;
      }
      get allowDirectSuper() {
        return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER3) > 0;
      }
      get inClass() {
        return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0;
      }
      get inClassAndNotInNonArrowFunction() {
        const flags = this.currentThisScopeFlags();
        return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION3) === 0;
      }
      get inStaticBlock() {
        for (let i = this.scopeStack.length - 1; ; i--) {
          const {
            flags
          } = this.scopeStack[i];
          if (flags & SCOPE_STATIC_BLOCK) {
            return true;
          }
          if (flags & (SCOPE_VAR3 | SCOPE_CLASS)) {
            return false;
          }
        }
      }
      get inNonArrowFunction() {
        return (this.currentThisScopeFlags() & SCOPE_FUNCTION3) > 0;
      }
      get treatFunctionsAsVar() {
        return this.treatFunctionsAsVarInScope(this.currentScope());
      }
      createScope(flags) {
        return new Scope6(flags);
      }
      enter(flags) {
        this.scopeStack.push(this.createScope(flags));
      }
      exit() {
        const scope = this.scopeStack.pop();
        return scope.flags;
      }
      treatFunctionsAsVarInScope(scope) {
        return !!(scope.flags & (SCOPE_FUNCTION3 | SCOPE_STATIC_BLOCK) || !this.parser.inModule && scope.flags & SCOPE_PROGRAM);
      }
      declareName(name2, bindingType, loc) {
        let scope = this.currentScope();
        if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {
          this.checkRedeclarationInScope(scope, name2, bindingType, loc);
          if (bindingType & BIND_SCOPE_FUNCTION) {
            scope.functions.add(name2);
          } else {
            scope.lexical.add(name2);
          }
          if (bindingType & BIND_SCOPE_LEXICAL) {
            this.maybeExportDefined(scope, name2);
          }
        } else if (bindingType & BIND_SCOPE_VAR) {
          for (let i = this.scopeStack.length - 1; i >= 0; --i) {
            scope = this.scopeStack[i];
            this.checkRedeclarationInScope(scope, name2, bindingType, loc);
            scope.var.add(name2);
            this.maybeExportDefined(scope, name2);
            if (scope.flags & SCOPE_VAR3)
              break;
          }
        }
        if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {
          this.undefinedExports.delete(name2);
        }
      }
      maybeExportDefined(scope, name2) {
        if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {
          this.undefinedExports.delete(name2);
        }
      }
      checkRedeclarationInScope(scope, name2, bindingType, loc) {
        if (this.isRedeclaredInScope(scope, name2, bindingType)) {
          this.parser.raise(Errors.VarRedeclaration, {
            at: loc,
            identifierName: name2
          });
        }
      }
      isRedeclaredInScope(scope, name2, bindingType) {
        if (!(bindingType & BIND_KIND_VALUE))
          return false;
        if (bindingType & BIND_SCOPE_LEXICAL) {
          return scope.lexical.has(name2) || scope.functions.has(name2) || scope.var.has(name2);
        }
        if (bindingType & BIND_SCOPE_FUNCTION) {
          return scope.lexical.has(name2) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name2);
        }
        return scope.lexical.has(name2) && !(scope.flags & SCOPE_SIMPLE_CATCH3 && scope.lexical.values().next().value === name2) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name2);
      }
      checkLocalExport(id) {
        const {
          name: name2
        } = id;
        const topLevelScope = this.scopeStack[0];
        if (!topLevelScope.lexical.has(name2) && !topLevelScope.var.has(name2) && !topLevelScope.functions.has(name2)) {
          this.undefinedExports.set(name2, id.loc.start);
        }
      }
      currentScope() {
        return this.scopeStack[this.scopeStack.length - 1];
      }
      currentVarScopeFlags() {
        for (let i = this.scopeStack.length - 1; ; i--) {
          const {
            flags
          } = this.scopeStack[i];
          if (flags & SCOPE_VAR3) {
            return flags;
          }
        }
      }
      currentThisScopeFlags() {
        for (let i = this.scopeStack.length - 1; ; i--) {
          const {
            flags
          } = this.scopeStack[i];
          if (flags & (SCOPE_VAR3 | SCOPE_CLASS) && !(flags & SCOPE_ARROW3)) {
            return flags;
          }
        }
      }
    };
    var FlowScope = class extends Scope6 {
      constructor(...args) {
        super(...args);
        this.declareFunctions = /* @__PURE__ */ new Set();
      }
    };
    var FlowScopeHandler = class extends ScopeHandler {
      createScope(flags) {
        return new FlowScope(flags);
      }
      declareName(name2, bindingType, loc) {
        const scope = this.currentScope();
        if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
          this.checkRedeclarationInScope(scope, name2, bindingType, loc);
          this.maybeExportDefined(scope, name2);
          scope.declareFunctions.add(name2);
          return;
        }
        super.declareName(name2, bindingType, loc);
      }
      isRedeclaredInScope(scope, name2, bindingType) {
        if (super.isRedeclaredInScope(scope, name2, bindingType))
          return true;
        if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
          return !scope.declareFunctions.has(name2) && (scope.lexical.has(name2) || scope.functions.has(name2));
        }
        return false;
      }
      checkLocalExport(id) {
        if (!this.scopeStack[0].declareFunctions.has(id.name)) {
          super.checkLocalExport(id);
        }
      }
    };
    var BaseParser = class {
      constructor() {
        this.sawUnambiguousESM = false;
        this.ambiguousScriptDifferentAst = false;
      }
      hasPlugin(pluginConfig) {
        if (typeof pluginConfig === "string") {
          return this.plugins.has(pluginConfig);
        } else {
          const [pluginName, pluginOptions] = pluginConfig;
          if (!this.hasPlugin(pluginName)) {
            return false;
          }
          const actualOptions = this.plugins.get(pluginName);
          for (const key2 of Object.keys(pluginOptions)) {
            if ((actualOptions == null ? void 0 : actualOptions[key2]) !== pluginOptions[key2]) {
              return false;
            }
          }
          return true;
        }
      }
      getPluginOption(plugin2, name2) {
        var _this$plugins$get;
        return (_this$plugins$get = this.plugins.get(plugin2)) == null ? void 0 : _this$plugins$get[name2];
      }
    };
    function setTrailingComments(node2, comments) {
      if (node2.trailingComments === void 0) {
        node2.trailingComments = comments;
      } else {
        node2.trailingComments.unshift(...comments);
      }
    }
    function setLeadingComments(node2, comments) {
      if (node2.leadingComments === void 0) {
        node2.leadingComments = comments;
      } else {
        node2.leadingComments.unshift(...comments);
      }
    }
    function setInnerComments(node2, comments) {
      if (node2.innerComments === void 0) {
        node2.innerComments = comments;
      } else {
        node2.innerComments.unshift(...comments);
      }
    }
    function adjustInnerComments(node2, elements, commentWS) {
      let lastElement = null;
      let i = elements.length;
      while (lastElement === null && i > 0) {
        lastElement = elements[--i];
      }
      if (lastElement === null || lastElement.start > commentWS.start) {
        setInnerComments(node2, commentWS.comments);
      } else {
        setTrailingComments(lastElement, commentWS.comments);
      }
    }
    var CommentsParser = class extends BaseParser {
      addComment(comment2) {
        if (this.filename)
          comment2.loc.filename = this.filename;
        this.state.comments.push(comment2);
      }
      processComment(node2) {
        const {
          commentStack
        } = this.state;
        const commentStackLength = commentStack.length;
        if (commentStackLength === 0)
          return;
        let i = commentStackLength - 1;
        const lastCommentWS = commentStack[i];
        if (lastCommentWS.start === node2.end) {
          lastCommentWS.leadingNode = node2;
          i--;
        }
        const {
          start: nodeStart
        } = node2;
        for (; i >= 0; i--) {
          const commentWS = commentStack[i];
          const commentEnd = commentWS.end;
          if (commentEnd > nodeStart) {
            commentWS.containingNode = node2;
            this.finalizeComment(commentWS);
            commentStack.splice(i, 1);
          } else {
            if (commentEnd === nodeStart) {
              commentWS.trailingNode = node2;
            }
            break;
          }
        }
      }
      finalizeComment(commentWS) {
        const {
          comments
        } = commentWS;
        if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {
          if (commentWS.leadingNode !== null) {
            setTrailingComments(commentWS.leadingNode, comments);
          }
          if (commentWS.trailingNode !== null) {
            setLeadingComments(commentWS.trailingNode, comments);
          }
        } else {
          const {
            containingNode: node2,
            start: commentStart
          } = commentWS;
          if (this.input.charCodeAt(commentStart - 1) === 44) {
            switch (node2.type) {
              case "ObjectExpression":
              case "ObjectPattern":
              case "RecordExpression":
                adjustInnerComments(node2, node2.properties, commentWS);
                break;
              case "CallExpression":
              case "OptionalCallExpression":
                adjustInnerComments(node2, node2.arguments, commentWS);
                break;
              case "FunctionDeclaration":
              case "FunctionExpression":
              case "ArrowFunctionExpression":
              case "ObjectMethod":
              case "ClassMethod":
              case "ClassPrivateMethod":
                adjustInnerComments(node2, node2.params, commentWS);
                break;
              case "ArrayExpression":
              case "ArrayPattern":
              case "TupleExpression":
                adjustInnerComments(node2, node2.elements, commentWS);
                break;
              case "ExportNamedDeclaration":
              case "ImportDeclaration":
                adjustInnerComments(node2, node2.specifiers, commentWS);
                break;
              default: {
                setInnerComments(node2, comments);
              }
            }
          } else {
            setInnerComments(node2, comments);
          }
        }
      }
      finalizeRemainingComments() {
        const {
          commentStack
        } = this.state;
        for (let i = commentStack.length - 1; i >= 0; i--) {
          this.finalizeComment(commentStack[i]);
        }
        this.state.commentStack = [];
      }
      resetPreviousNodeTrailingComments(node2) {
        const {
          commentStack
        } = this.state;
        const {
          length
        } = commentStack;
        if (length === 0)
          return;
        const commentWS = commentStack[length - 1];
        if (commentWS.leadingNode === node2) {
          commentWS.leadingNode = null;
        }
      }
      takeSurroundingComments(node2, start3, end) {
        const {
          commentStack
        } = this.state;
        const commentStackLength = commentStack.length;
        if (commentStackLength === 0)
          return;
        let i = commentStackLength - 1;
        for (; i >= 0; i--) {
          const commentWS = commentStack[i];
          const commentEnd = commentWS.end;
          const commentStart = commentWS.start;
          if (commentStart === end) {
            commentWS.leadingNode = node2;
          } else if (commentEnd === start3) {
            commentWS.trailingNode = node2;
          } else if (commentEnd < start3) {
            break;
          }
        }
      }
    };
    var lineBreak3 = /\r\n?|[\n\u2028\u2029]/;
    var lineBreakG3 = new RegExp(lineBreak3.source, "g");
    function isNewLine3(code2) {
      switch (code2) {
        case 10:
        case 13:
        case 8232:
        case 8233:
          return true;
        default:
          return false;
      }
    }
    var skipWhiteSpace3 = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
    var skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
    var skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
    function isWhitespace(code2) {
      switch (code2) {
        case 9:
        case 11:
        case 12:
        case 32:
        case 160:
        case 5760:
        case 8192:
        case 8193:
        case 8194:
        case 8195:
        case 8196:
        case 8197:
        case 8198:
        case 8199:
        case 8200:
        case 8201:
        case 8202:
        case 8239:
        case 8287:
        case 12288:
        case 65279:
          return true;
        default:
          return false;
      }
    }
    var State2 = class {
      constructor() {
        this.strict = void 0;
        this.curLine = void 0;
        this.lineStart = void 0;
        this.startLoc = void 0;
        this.endLoc = void 0;
        this.errors = [];
        this.potentialArrowAt = -1;
        this.noArrowAt = [];
        this.noArrowParamsConversionAt = [];
        this.maybeInArrowParameters = false;
        this.inType = false;
        this.noAnonFunctionType = false;
        this.hasFlowComment = false;
        this.isAmbientContext = false;
        this.inAbstractClass = false;
        this.inDisallowConditionalTypesContext = false;
        this.topicContext = {
          maxNumOfResolvableTopics: 0,
          maxTopicIndex: null
        };
        this.soloAwait = false;
        this.inFSharpPipelineDirectBody = false;
        this.labels = [];
        this.comments = [];
        this.commentStack = [];
        this.pos = 0;
        this.type = 137;
        this.value = null;
        this.start = 0;
        this.end = 0;
        this.lastTokEndLoc = null;
        this.lastTokStartLoc = null;
        this.lastTokStart = 0;
        this.context = [types3.brace];
        this.canStartJSXElement = true;
        this.containsEsc = false;
        this.firstInvalidTemplateEscapePos = null;
        this.strictErrors = /* @__PURE__ */ new Map();
        this.tokensLength = 0;
      }
      init({
        strictMode,
        sourceType,
        startLine,
        startColumn
      }) {
        this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module";
        this.curLine = startLine;
        this.lineStart = -startColumn;
        this.startLoc = this.endLoc = new Position5(startLine, startColumn, 0);
      }
      curPosition() {
        return new Position5(this.curLine, this.pos - this.lineStart, this.pos);
      }
      clone(skipArrays) {
        const state = new State2();
        const keys2 = Object.keys(this);
        for (let i = 0, length = keys2.length; i < length; i++) {
          const key2 = keys2[i];
          let val = this[key2];
          if (!skipArrays && Array.isArray(val)) {
            val = val.slice();
          }
          state[key2] = val;
        }
        return state;
      }
    };
    var _isDigit = function isDigit(code2) {
      return code2 >= 48 && code2 <= 57;
    };
    var forbiddenNumericSeparatorSiblings = {
      decBinOct: /* @__PURE__ */ new Set([46, 66, 69, 79, 95, 98, 101, 111]),
      hex: /* @__PURE__ */ new Set([46, 88, 95, 120])
    };
    var isAllowedNumericSeparatorSibling = {
      bin: (ch) => ch === 48 || ch === 49,
      oct: (ch) => ch >= 48 && ch <= 55,
      dec: (ch) => ch >= 48 && ch <= 57,
      hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
    };
    function readStringContents(type, input, pos2, lineStart, curLine, errors) {
      const initialPos = pos2;
      const initialLineStart = lineStart;
      const initialCurLine = curLine;
      let out = "";
      let firstInvalidLoc = null;
      let chunkStart = pos2;
      const {
        length
      } = input;
      for (; ; ) {
        if (pos2 >= length) {
          errors.unterminated(initialPos, initialLineStart, initialCurLine);
          out += input.slice(chunkStart, pos2);
          break;
        }
        const ch = input.charCodeAt(pos2);
        if (isStringEnd(type, ch, input, pos2)) {
          out += input.slice(chunkStart, pos2);
          break;
        }
        if (ch === 92) {
          out += input.slice(chunkStart, pos2);
          const res = readEscapedChar(input, pos2, lineStart, curLine, type === "template", errors);
          if (res.ch === null && !firstInvalidLoc) {
            firstInvalidLoc = {
              pos: pos2,
              lineStart,
              curLine
            };
          } else {
            out += res.ch;
          }
          ({
            pos: pos2,
            lineStart,
            curLine
          } = res);
          chunkStart = pos2;
        } else if (ch === 8232 || ch === 8233) {
          ++pos2;
          ++curLine;
          lineStart = pos2;
        } else if (ch === 10 || ch === 13) {
          if (type === "template") {
            out += input.slice(chunkStart, pos2) + "\n";
            ++pos2;
            if (ch === 13 && input.charCodeAt(pos2) === 10) {
              ++pos2;
            }
            ++curLine;
            chunkStart = lineStart = pos2;
          } else {
            errors.unterminated(initialPos, initialLineStart, initialCurLine);
          }
        } else {
          ++pos2;
        }
      }
      return {
        pos: pos2,
        str: out,
        firstInvalidLoc,
        lineStart,
        curLine,
        containsInvalid: !!firstInvalidLoc
      };
    }
    function isStringEnd(type, ch, input, pos2) {
      if (type === "template") {
        return ch === 96 || ch === 36 && input.charCodeAt(pos2 + 1) === 123;
      }
      return ch === (type === "double" ? 34 : 39);
    }
    function readEscapedChar(input, pos2, lineStart, curLine, inTemplate, errors) {
      const throwOnInvalid = !inTemplate;
      pos2++;
      const res = (ch2) => ({
        pos: pos2,
        ch: ch2,
        lineStart,
        curLine
      });
      const ch = input.charCodeAt(pos2++);
      switch (ch) {
        case 110:
          return res("\n");
        case 114:
          return res("\r");
        case 120: {
          let code2;
          ({
            code: code2,
            pos: pos2
          } = readHexChar(input, pos2, lineStart, curLine, 2, false, throwOnInvalid, errors));
          return res(code2 === null ? null : String.fromCharCode(code2));
        }
        case 117: {
          let code2;
          ({
            code: code2,
            pos: pos2
          } = readCodePoint(input, pos2, lineStart, curLine, throwOnInvalid, errors));
          return res(code2 === null ? null : String.fromCodePoint(code2));
        }
        case 116:
          return res("	");
        case 98:
          return res("\b");
        case 118:
          return res("\v");
        case 102:
          return res("\f");
        case 13:
          if (input.charCodeAt(pos2) === 10) {
            ++pos2;
          }
        case 10:
          lineStart = pos2;
          ++curLine;
        case 8232:
        case 8233:
          return res("");
        case 56:
        case 57:
          if (inTemplate) {
            return res(null);
          } else {
            errors.strictNumericEscape(pos2 - 1, lineStart, curLine);
          }
        default:
          if (ch >= 48 && ch <= 55) {
            const startPos = pos2 - 1;
            const match = input.slice(startPos, pos2 + 2).match(/^[0-7]+/);
            let octalStr = match[0];
            let octal = parseInt(octalStr, 8);
            if (octal > 255) {
              octalStr = octalStr.slice(0, -1);
              octal = parseInt(octalStr, 8);
            }
            pos2 += octalStr.length - 1;
            const next = input.charCodeAt(pos2);
            if (octalStr !== "0" || next === 56 || next === 57) {
              if (inTemplate) {
                return res(null);
              } else {
                errors.strictNumericEscape(startPos, lineStart, curLine);
              }
            }
            return res(String.fromCharCode(octal));
          }
          return res(String.fromCharCode(ch));
      }
    }
    function readHexChar(input, pos2, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
      const initialPos = pos2;
      let n;
      ({
        n,
        pos: pos2
      } = readInt(input, pos2, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
      if (n === null) {
        if (throwOnInvalid) {
          errors.invalidEscapeSequence(initialPos, lineStart, curLine);
        } else {
          pos2 = initialPos - 1;
        }
      }
      return {
        code: n,
        pos: pos2
      };
    }
    function readInt(input, pos2, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
      const start3 = pos2;
      const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
      const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
      let invalid2 = false;
      let total = 0;
      for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
        const code2 = input.charCodeAt(pos2);
        let val;
        if (code2 === 95 && allowNumSeparator !== "bail") {
          const prev = input.charCodeAt(pos2 - 1);
          const next = input.charCodeAt(pos2 + 1);
          if (!allowNumSeparator) {
            if (bailOnError)
              return {
                n: null,
                pos: pos2
              };
            errors.numericSeparatorInEscapeSequence(pos2, lineStart, curLine);
          } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
            if (bailOnError)
              return {
                n: null,
                pos: pos2
              };
            errors.unexpectedNumericSeparator(pos2, lineStart, curLine);
          }
          ++pos2;
          continue;
        }
        if (code2 >= 97) {
          val = code2 - 97 + 10;
        } else if (code2 >= 65) {
          val = code2 - 65 + 10;
        } else if (_isDigit(code2)) {
          val = code2 - 48;
        } else {
          val = Infinity;
        }
        if (val >= radix) {
          if (val <= 9 && bailOnError) {
            return {
              n: null,
              pos: pos2
            };
          } else if (val <= 9 && errors.invalidDigit(pos2, lineStart, curLine, radix)) {
            val = 0;
          } else if (forceLen) {
            val = 0;
            invalid2 = true;
          } else {
            break;
          }
        }
        ++pos2;
        total = total * radix + val;
      }
      if (pos2 === start3 || len != null && pos2 - start3 !== len || invalid2) {
        return {
          n: null,
          pos: pos2
        };
      }
      return {
        n: total,
        pos: pos2
      };
    }
    function readCodePoint(input, pos2, lineStart, curLine, throwOnInvalid, errors) {
      const ch = input.charCodeAt(pos2);
      let code2;
      if (ch === 123) {
        ++pos2;
        ({
          code: code2,
          pos: pos2
        } = readHexChar(input, pos2, lineStart, curLine, input.indexOf("}", pos2) - pos2, true, throwOnInvalid, errors));
        ++pos2;
        if (code2 !== null && code2 > 1114111) {
          if (throwOnInvalid) {
            errors.invalidCodePoint(pos2, lineStart, curLine);
          } else {
            return {
              code: null,
              pos: pos2
            };
          }
        }
      } else {
        ({
          code: code2,
          pos: pos2
        } = readHexChar(input, pos2, lineStart, curLine, 4, false, throwOnInvalid, errors));
      }
      return {
        code: code2,
        pos: pos2
      };
    }
    var _excluded = ["at"];
    var _excluded2 = ["at"];
    function buildPosition(pos2, lineStart, curLine) {
      return new Position5(curLine, pos2 - lineStart, pos2);
    }
    var VALID_REGEX_FLAGS = /* @__PURE__ */ new Set([103, 109, 115, 105, 121, 117, 100, 118]);
    var Token5 = class {
      constructor(state) {
        this.type = state.type;
        this.value = state.value;
        this.start = state.start;
        this.end = state.end;
        this.loc = new SourceLocation5(state.startLoc, state.endLoc);
      }
    };
    var Tokenizer = class extends CommentsParser {
      constructor(options, input) {
        super();
        this.isLookahead = void 0;
        this.tokens = [];
        this.errorHandlers_readInt = {
          invalidDigit: (pos2, lineStart, curLine, radix) => {
            if (!this.options.errorRecovery)
              return false;
            this.raise(Errors.InvalidDigit, {
              at: buildPosition(pos2, lineStart, curLine),
              radix
            });
            return true;
          },
          numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
          unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)
        };
        this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {
          invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
          invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)
        });
        this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
          strictNumericEscape: (pos2, lineStart, curLine) => {
            this.recordStrictModeErrors(Errors.StrictNumericEscape, {
              at: buildPosition(pos2, lineStart, curLine)
            });
          },
          unterminated: (pos2, lineStart, curLine) => {
            throw this.raise(Errors.UnterminatedString, {
              at: buildPosition(pos2 - 1, lineStart, curLine)
            });
          }
        });
        this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
          strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
          unterminated: (pos2, lineStart, curLine) => {
            throw this.raise(Errors.UnterminatedTemplate, {
              at: buildPosition(pos2, lineStart, curLine)
            });
          }
        });
        this.state = new State2();
        this.state.init(options);
        this.input = input;
        this.length = input.length;
        this.isLookahead = false;
      }
      pushToken(token2) {
        this.tokens.length = this.state.tokensLength;
        this.tokens.push(token2);
        ++this.state.tokensLength;
      }
      next() {
        this.checkKeywordEscapes();
        if (this.options.tokens) {
          this.pushToken(new Token5(this.state));
        }
        this.state.lastTokStart = this.state.start;
        this.state.lastTokEndLoc = this.state.endLoc;
        this.state.lastTokStartLoc = this.state.startLoc;
        this.nextToken();
      }
      eat(type) {
        if (this.match(type)) {
          this.next();
          return true;
        } else {
          return false;
        }
      }
      match(type) {
        return this.state.type === type;
      }
      createLookaheadState(state) {
        return {
          pos: state.pos,
          value: null,
          type: state.type,
          start: state.start,
          end: state.end,
          context: [this.curContext()],
          inType: state.inType,
          startLoc: state.startLoc,
          lastTokEndLoc: state.lastTokEndLoc,
          curLine: state.curLine,
          lineStart: state.lineStart,
          curPosition: state.curPosition
        };
      }
      lookahead() {
        const old = this.state;
        this.state = this.createLookaheadState(old);
        this.isLookahead = true;
        this.nextToken();
        this.isLookahead = false;
        const curr = this.state;
        this.state = old;
        return curr;
      }
      nextTokenStart() {
        return this.nextTokenStartSince(this.state.pos);
      }
      nextTokenStartSince(pos2) {
        skipWhiteSpace3.lastIndex = pos2;
        return skipWhiteSpace3.test(this.input) ? skipWhiteSpace3.lastIndex : pos2;
      }
      lookaheadCharCode() {
        return this.input.charCodeAt(this.nextTokenStart());
      }
      nextTokenInLineStart() {
        return this.nextTokenInLineStartSince(this.state.pos);
      }
      nextTokenInLineStartSince(pos2) {
        skipWhiteSpaceInLine.lastIndex = pos2;
        return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos2;
      }
      lookaheadInLineCharCode() {
        return this.input.charCodeAt(this.nextTokenInLineStart());
      }
      codePointAtPos(pos2) {
        let cp = this.input.charCodeAt(pos2);
        if ((cp & 64512) === 55296 && ++pos2 < this.input.length) {
          const trail = this.input.charCodeAt(pos2);
          if ((trail & 64512) === 56320) {
            cp = 65536 + ((cp & 1023) << 10) + (trail & 1023);
          }
        }
        return cp;
      }
      setStrict(strict) {
        this.state.strict = strict;
        if (strict) {
          this.state.strictErrors.forEach(([toParseError, at3]) => this.raise(toParseError, {
            at: at3
          }));
          this.state.strictErrors.clear();
        }
      }
      curContext() {
        return this.state.context[this.state.context.length - 1];
      }
      nextToken() {
        this.skipSpace();
        this.state.start = this.state.pos;
        if (!this.isLookahead)
          this.state.startLoc = this.state.curPosition();
        if (this.state.pos >= this.length) {
          this.finishToken(137);
          return;
        }
        this.getTokenFromCode(this.codePointAtPos(this.state.pos));
      }
      skipBlockComment(commentEnd) {
        let startLoc;
        if (!this.isLookahead)
          startLoc = this.state.curPosition();
        const start3 = this.state.pos;
        const end = this.input.indexOf(commentEnd, start3 + 2);
        if (end === -1) {
          throw this.raise(Errors.UnterminatedComment, {
            at: this.state.curPosition()
          });
        }
        this.state.pos = end + commentEnd.length;
        lineBreakG3.lastIndex = start3 + 2;
        while (lineBreakG3.test(this.input) && lineBreakG3.lastIndex <= end) {
          ++this.state.curLine;
          this.state.lineStart = lineBreakG3.lastIndex;
        }
        if (this.isLookahead)
          return;
        const comment2 = {
          type: "CommentBlock",
          value: this.input.slice(start3 + 2, end),
          start: start3,
          end: end + commentEnd.length,
          loc: new SourceLocation5(startLoc, this.state.curPosition())
        };
        if (this.options.tokens)
          this.pushToken(comment2);
        return comment2;
      }
      skipLineComment(startSkip) {
        const start3 = this.state.pos;
        let startLoc;
        if (!this.isLookahead)
          startLoc = this.state.curPosition();
        let ch = this.input.charCodeAt(this.state.pos += startSkip);
        if (this.state.pos < this.length) {
          while (!isNewLine3(ch) && ++this.state.pos < this.length) {
            ch = this.input.charCodeAt(this.state.pos);
          }
        }
        if (this.isLookahead)
          return;
        const end = this.state.pos;
        const value2 = this.input.slice(start3 + startSkip, end);
        const comment2 = {
          type: "CommentLine",
          value: value2,
          start: start3,
          end,
          loc: new SourceLocation5(startLoc, this.state.curPosition())
        };
        if (this.options.tokens)
          this.pushToken(comment2);
        return comment2;
      }
      skipSpace() {
        const spaceStart = this.state.pos;
        const comments = [];
        loop:
          while (this.state.pos < this.length) {
            const ch = this.input.charCodeAt(this.state.pos);
            switch (ch) {
              case 32:
              case 160:
              case 9:
                ++this.state.pos;
                break;
              case 13:
                if (this.input.charCodeAt(this.state.pos + 1) === 10) {
                  ++this.state.pos;
                }
              case 10:
              case 8232:
              case 8233:
                ++this.state.pos;
                ++this.state.curLine;
                this.state.lineStart = this.state.pos;
                break;
              case 47:
                switch (this.input.charCodeAt(this.state.pos + 1)) {
                  case 42: {
                    const comment2 = this.skipBlockComment("*/");
                    if (comment2 !== void 0) {
                      this.addComment(comment2);
                      if (this.options.attachComment)
                        comments.push(comment2);
                    }
                    break;
                  }
                  case 47: {
                    const comment2 = this.skipLineComment(2);
                    if (comment2 !== void 0) {
                      this.addComment(comment2);
                      if (this.options.attachComment)
                        comments.push(comment2);
                    }
                    break;
                  }
                  default:
                    break loop;
                }
                break;
              default:
                if (isWhitespace(ch)) {
                  ++this.state.pos;
                } else if (ch === 45 && !this.inModule && this.options.annexB) {
                  const pos2 = this.state.pos;
                  if (this.input.charCodeAt(pos2 + 1) === 45 && this.input.charCodeAt(pos2 + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
                    const comment2 = this.skipLineComment(3);
                    if (comment2 !== void 0) {
                      this.addComment(comment2);
                      if (this.options.attachComment)
                        comments.push(comment2);
                    }
                  } else {
                    break loop;
                  }
                } else if (ch === 60 && !this.inModule && this.options.annexB) {
                  const pos2 = this.state.pos;
                  if (this.input.charCodeAt(pos2 + 1) === 33 && this.input.charCodeAt(pos2 + 2) === 45 && this.input.charCodeAt(pos2 + 3) === 45) {
                    const comment2 = this.skipLineComment(4);
                    if (comment2 !== void 0) {
                      this.addComment(comment2);
                      if (this.options.attachComment)
                        comments.push(comment2);
                    }
                  } else {
                    break loop;
                  }
                } else {
                  break loop;
                }
            }
          }
        if (comments.length > 0) {
          const end = this.state.pos;
          const commentWhitespace = {
            start: spaceStart,
            end,
            comments,
            leadingNode: null,
            trailingNode: null,
            containingNode: null
          };
          this.state.commentStack.push(commentWhitespace);
        }
      }
      finishToken(type, val) {
        this.state.end = this.state.pos;
        this.state.endLoc = this.state.curPosition();
        const prevType = this.state.type;
        this.state.type = type;
        this.state.value = val;
        if (!this.isLookahead) {
          this.updateContext(prevType);
        }
      }
      replaceToken(type) {
        this.state.type = type;
        this.updateContext();
      }
      readToken_numberSign() {
        if (this.state.pos === 0 && this.readToken_interpreter()) {
          return;
        }
        const nextPos = this.state.pos + 1;
        const next = this.codePointAtPos(nextPos);
        if (next >= 48 && next <= 57) {
          throw this.raise(Errors.UnexpectedDigitAfterHash, {
            at: this.state.curPosition()
          });
        }
        if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
          this.expectPlugin("recordAndTuple");
          if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") {
            throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, {
              at: this.state.curPosition()
            });
          }
          this.state.pos += 2;
          if (next === 123) {
            this.finishToken(7);
          } else {
            this.finishToken(1);
          }
        } else if (isIdentifierStart3(next)) {
          ++this.state.pos;
          this.finishToken(136, this.readWord1(next));
        } else if (next === 92) {
          ++this.state.pos;
          this.finishToken(136, this.readWord1());
        } else {
          this.finishOp(27, 1);
        }
      }
      readToken_dot() {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next >= 48 && next <= 57) {
          this.readNumber(true);
          return;
        }
        if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
          this.state.pos += 3;
          this.finishToken(21);
        } else {
          ++this.state.pos;
          this.finishToken(16);
        }
      }
      readToken_slash() {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next === 61) {
          this.finishOp(31, 2);
        } else {
          this.finishOp(56, 1);
        }
      }
      readToken_interpreter() {
        if (this.state.pos !== 0 || this.length < 2)
          return false;
        let ch = this.input.charCodeAt(this.state.pos + 1);
        if (ch !== 33)
          return false;
        const start3 = this.state.pos;
        this.state.pos += 1;
        while (!isNewLine3(ch) && ++this.state.pos < this.length) {
          ch = this.input.charCodeAt(this.state.pos);
        }
        const value2 = this.input.slice(start3 + 2, this.state.pos);
        this.finishToken(28, value2);
        return true;
      }
      readToken_mult_modulo(code2) {
        let type = code2 === 42 ? 55 : 54;
        let width = 1;
        let next = this.input.charCodeAt(this.state.pos + 1);
        if (code2 === 42 && next === 42) {
          width++;
          next = this.input.charCodeAt(this.state.pos + 2);
          type = 57;
        }
        if (next === 61 && !this.state.inType) {
          width++;
          type = code2 === 37 ? 33 : 30;
        }
        this.finishOp(type, width);
      }
      readToken_pipe_amp(code2) {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next === code2) {
          if (this.input.charCodeAt(this.state.pos + 2) === 61) {
            this.finishOp(30, 3);
          } else {
            this.finishOp(code2 === 124 ? 41 : 42, 2);
          }
          return;
        }
        if (code2 === 124) {
          if (next === 62) {
            this.finishOp(39, 2);
            return;
          }
          if (this.hasPlugin("recordAndTuple") && next === 125) {
            if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
              throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, {
                at: this.state.curPosition()
              });
            }
            this.state.pos += 2;
            this.finishToken(9);
            return;
          }
          if (this.hasPlugin("recordAndTuple") && next === 93) {
            if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
              throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, {
                at: this.state.curPosition()
              });
            }
            this.state.pos += 2;
            this.finishToken(4);
            return;
          }
        }
        if (next === 61) {
          this.finishOp(30, 2);
          return;
        }
        this.finishOp(code2 === 124 ? 43 : 45, 1);
      }
      readToken_caret() {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next === 61 && !this.state.inType) {
          this.finishOp(32, 2);
        } else if (next === 94 && this.hasPlugin(["pipelineOperator", {
          proposal: "hack",
          topicToken: "^^"
        }])) {
          this.finishOp(37, 2);
          const lookaheadCh = this.input.codePointAt(this.state.pos);
          if (lookaheadCh === 94) {
            this.unexpected();
          }
        } else {
          this.finishOp(44, 1);
        }
      }
      readToken_atSign() {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next === 64 && this.hasPlugin(["pipelineOperator", {
          proposal: "hack",
          topicToken: "@@"
        }])) {
          this.finishOp(38, 2);
        } else {
          this.finishOp(26, 1);
        }
      }
      readToken_plus_min(code2) {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next === code2) {
          this.finishOp(34, 2);
          return;
        }
        if (next === 61) {
          this.finishOp(30, 2);
        } else {
          this.finishOp(53, 1);
        }
      }
      readToken_lt() {
        const {
          pos: pos2
        } = this.state;
        const next = this.input.charCodeAt(pos2 + 1);
        if (next === 60) {
          if (this.input.charCodeAt(pos2 + 2) === 61) {
            this.finishOp(30, 3);
            return;
          }
          this.finishOp(51, 2);
          return;
        }
        if (next === 61) {
          this.finishOp(49, 2);
          return;
        }
        this.finishOp(47, 1);
      }
      readToken_gt() {
        const {
          pos: pos2
        } = this.state;
        const next = this.input.charCodeAt(pos2 + 1);
        if (next === 62) {
          const size = this.input.charCodeAt(pos2 + 2) === 62 ? 3 : 2;
          if (this.input.charCodeAt(pos2 + size) === 61) {
            this.finishOp(30, size + 1);
            return;
          }
          this.finishOp(52, size);
          return;
        }
        if (next === 61) {
          this.finishOp(49, 2);
          return;
        }
        this.finishOp(48, 1);
      }
      readToken_eq_excl(code2) {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (next === 61) {
          this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
          return;
        }
        if (code2 === 61 && next === 62) {
          this.state.pos += 2;
          this.finishToken(19);
          return;
        }
        this.finishOp(code2 === 61 ? 29 : 35, 1);
      }
      readToken_question() {
        const next = this.input.charCodeAt(this.state.pos + 1);
        const next2 = this.input.charCodeAt(this.state.pos + 2);
        if (next === 63) {
          if (next2 === 61) {
            this.finishOp(30, 3);
          } else {
            this.finishOp(40, 2);
          }
        } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
          this.state.pos += 2;
          this.finishToken(18);
        } else {
          ++this.state.pos;
          this.finishToken(17);
        }
      }
      getTokenFromCode(code2) {
        switch (code2) {
          case 46:
            this.readToken_dot();
            return;
          case 40:
            ++this.state.pos;
            this.finishToken(10);
            return;
          case 41:
            ++this.state.pos;
            this.finishToken(11);
            return;
          case 59:
            ++this.state.pos;
            this.finishToken(13);
            return;
          case 44:
            ++this.state.pos;
            this.finishToken(12);
            return;
          case 91:
            if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
              if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
                throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, {
                  at: this.state.curPosition()
                });
              }
              this.state.pos += 2;
              this.finishToken(2);
            } else {
              ++this.state.pos;
              this.finishToken(0);
            }
            return;
          case 93:
            ++this.state.pos;
            this.finishToken(3);
            return;
          case 123:
            if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
              if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
                throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, {
                  at: this.state.curPosition()
                });
              }
              this.state.pos += 2;
              this.finishToken(6);
            } else {
              ++this.state.pos;
              this.finishToken(5);
            }
            return;
          case 125:
            ++this.state.pos;
            this.finishToken(8);
            return;
          case 58:
            if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) {
              this.finishOp(15, 2);
            } else {
              ++this.state.pos;
              this.finishToken(14);
            }
            return;
          case 63:
            this.readToken_question();
            return;
          case 96:
            this.readTemplateToken();
            return;
          case 48: {
            const next = this.input.charCodeAt(this.state.pos + 1);
            if (next === 120 || next === 88) {
              this.readRadixNumber(16);
              return;
            }
            if (next === 111 || next === 79) {
              this.readRadixNumber(8);
              return;
            }
            if (next === 98 || next === 66) {
              this.readRadixNumber(2);
              return;
            }
          }
          case 49:
          case 50:
          case 51:
          case 52:
          case 53:
          case 54:
          case 55:
          case 56:
          case 57:
            this.readNumber(false);
            return;
          case 34:
          case 39:
            this.readString(code2);
            return;
          case 47:
            this.readToken_slash();
            return;
          case 37:
          case 42:
            this.readToken_mult_modulo(code2);
            return;
          case 124:
          case 38:
            this.readToken_pipe_amp(code2);
            return;
          case 94:
            this.readToken_caret();
            return;
          case 43:
          case 45:
            this.readToken_plus_min(code2);
            return;
          case 60:
            this.readToken_lt();
            return;
          case 62:
            this.readToken_gt();
            return;
          case 61:
          case 33:
            this.readToken_eq_excl(code2);
            return;
          case 126:
            this.finishOp(36, 1);
            return;
          case 64:
            this.readToken_atSign();
            return;
          case 35:
            this.readToken_numberSign();
            return;
          case 92:
            this.readWord();
            return;
          default:
            if (isIdentifierStart3(code2)) {
              this.readWord(code2);
              return;
            }
        }
        throw this.raise(Errors.InvalidOrUnexpectedToken, {
          at: this.state.curPosition(),
          unexpected: String.fromCodePoint(code2)
        });
      }
      finishOp(type, size) {
        const str = this.input.slice(this.state.pos, this.state.pos + size);
        this.state.pos += size;
        this.finishToken(type, str);
      }
      readRegexp() {
        const startLoc = this.state.startLoc;
        const start3 = this.state.start + 1;
        let escaped, inClass;
        let {
          pos: pos2
        } = this.state;
        for (; ; ++pos2) {
          if (pos2 >= this.length) {
            throw this.raise(Errors.UnterminatedRegExp, {
              at: createPositionWithColumnOffset(startLoc, 1)
            });
          }
          const ch = this.input.charCodeAt(pos2);
          if (isNewLine3(ch)) {
            throw this.raise(Errors.UnterminatedRegExp, {
              at: createPositionWithColumnOffset(startLoc, 1)
            });
          }
          if (escaped) {
            escaped = false;
          } else {
            if (ch === 91) {
              inClass = true;
            } else if (ch === 93 && inClass) {
              inClass = false;
            } else if (ch === 47 && !inClass) {
              break;
            }
            escaped = ch === 92;
          }
        }
        const content3 = this.input.slice(start3, pos2);
        ++pos2;
        let mods = "";
        const nextPos = () => createPositionWithColumnOffset(startLoc, pos2 + 2 - start3);
        while (pos2 < this.length) {
          const cp = this.codePointAtPos(pos2);
          const char = String.fromCharCode(cp);
          if (VALID_REGEX_FLAGS.has(cp)) {
            if (cp === 118) {
              this.expectPlugin("regexpUnicodeSets", nextPos());
              if (mods.includes("u")) {
                this.raise(Errors.IncompatibleRegExpUVFlags, {
                  at: nextPos()
                });
              }
            } else if (cp === 117) {
              if (mods.includes("v")) {
                this.raise(Errors.IncompatibleRegExpUVFlags, {
                  at: nextPos()
                });
              }
            }
            if (mods.includes(char)) {
              this.raise(Errors.DuplicateRegExpFlags, {
                at: nextPos()
              });
            }
          } else if (isIdentifierChar3(cp) || cp === 92) {
            this.raise(Errors.MalformedRegExpFlags, {
              at: nextPos()
            });
          } else {
            break;
          }
          ++pos2;
          mods += char;
        }
        this.state.pos = pos2;
        this.finishToken(135, {
          pattern: content3,
          flags: mods
        });
      }
      readInt(radix, len, forceLen = false, allowNumSeparator = true) {
        const {
          n,
          pos: pos2
        } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
        this.state.pos = pos2;
        return n;
      }
      readRadixNumber(radix) {
        const startLoc = this.state.curPosition();
        let isBigInt = false;
        this.state.pos += 2;
        const val = this.readInt(radix);
        if (val == null) {
          this.raise(Errors.InvalidDigit, {
            at: createPositionWithColumnOffset(startLoc, 2),
            radix
          });
        }
        const next = this.input.charCodeAt(this.state.pos);
        if (next === 110) {
          ++this.state.pos;
          isBigInt = true;
        } else if (next === 109) {
          throw this.raise(Errors.InvalidDecimal, {
            at: startLoc
          });
        }
        if (isIdentifierStart3(this.codePointAtPos(this.state.pos))) {
          throw this.raise(Errors.NumberIdentifier, {
            at: this.state.curPosition()
          });
        }
        if (isBigInt) {
          const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
          this.finishToken(133, str);
          return;
        }
        this.finishToken(132, val);
      }
      readNumber(startsWithDot) {
        const start3 = this.state.pos;
        const startLoc = this.state.curPosition();
        let isFloat = false;
        let isBigInt = false;
        let isDecimal2 = false;
        let hasExponent = false;
        let isOctal = false;
        if (!startsWithDot && this.readInt(10) === null) {
          this.raise(Errors.InvalidNumber, {
            at: this.state.curPosition()
          });
        }
        const hasLeadingZero = this.state.pos - start3 >= 2 && this.input.charCodeAt(start3) === 48;
        if (hasLeadingZero) {
          const integer = this.input.slice(start3, this.state.pos);
          this.recordStrictModeErrors(Errors.StrictOctalLiteral, {
            at: startLoc
          });
          if (!this.state.strict) {
            const underscorePos = integer.indexOf("_");
            if (underscorePos > 0) {
              this.raise(Errors.ZeroDigitNumericSeparator, {
                at: createPositionWithColumnOffset(startLoc, underscorePos)
              });
            }
          }
          isOctal = hasLeadingZero && !/[89]/.test(integer);
        }
        let next = this.input.charCodeAt(this.state.pos);
        if (next === 46 && !isOctal) {
          ++this.state.pos;
          this.readInt(10);
          isFloat = true;
          next = this.input.charCodeAt(this.state.pos);
        }
        if ((next === 69 || next === 101) && !isOctal) {
          next = this.input.charCodeAt(++this.state.pos);
          if (next === 43 || next === 45) {
            ++this.state.pos;
          }
          if (this.readInt(10) === null) {
            this.raise(Errors.InvalidOrMissingExponent, {
              at: startLoc
            });
          }
          isFloat = true;
          hasExponent = true;
          next = this.input.charCodeAt(this.state.pos);
        }
        if (next === 110) {
          if (isFloat || hasLeadingZero) {
            this.raise(Errors.InvalidBigIntLiteral, {
              at: startLoc
            });
          }
          ++this.state.pos;
          isBigInt = true;
        }
        if (next === 109) {
          this.expectPlugin("decimal", this.state.curPosition());
          if (hasExponent || hasLeadingZero) {
            this.raise(Errors.InvalidDecimal, {
              at: startLoc
            });
          }
          ++this.state.pos;
          isDecimal2 = true;
        }
        if (isIdentifierStart3(this.codePointAtPos(this.state.pos))) {
          throw this.raise(Errors.NumberIdentifier, {
            at: this.state.curPosition()
          });
        }
        const str = this.input.slice(start3, this.state.pos).replace(/[_mn]/g, "");
        if (isBigInt) {
          this.finishToken(133, str);
          return;
        }
        if (isDecimal2) {
          this.finishToken(134, str);
          return;
        }
        const val = isOctal ? parseInt(str, 8) : parseFloat(str);
        this.finishToken(132, val);
      }
      readCodePoint(throwOnInvalid) {
        const {
          code: code2,
          pos: pos2
        } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
        this.state.pos = pos2;
        return code2;
      }
      readString(quote) {
        const {
          str,
          pos: pos2,
          curLine,
          lineStart
        } = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
        this.state.pos = pos2 + 1;
        this.state.lineStart = lineStart;
        this.state.curLine = curLine;
        this.finishToken(131, str);
      }
      readTemplateContinuation() {
        if (!this.match(8)) {
          this.unexpected(null, 8);
        }
        this.state.pos--;
        this.readTemplateToken();
      }
      readTemplateToken() {
        const opening = this.input[this.state.pos];
        const {
          str,
          firstInvalidLoc,
          pos: pos2,
          curLine,
          lineStart
        } = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
        this.state.pos = pos2 + 1;
        this.state.lineStart = lineStart;
        this.state.curLine = curLine;
        if (firstInvalidLoc) {
          this.state.firstInvalidTemplateEscapePos = new Position5(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos);
        }
        if (this.input.codePointAt(pos2) === 96) {
          this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
        } else {
          this.state.pos++;
          this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
        }
      }
      recordStrictModeErrors(toParseError, {
        at: at3
      }) {
        const index2 = at3.index;
        if (this.state.strict && !this.state.strictErrors.has(index2)) {
          this.raise(toParseError, {
            at: at3
          });
        } else {
          this.state.strictErrors.set(index2, [toParseError, at3]);
        }
      }
      readWord1(firstCode) {
        this.state.containsEsc = false;
        let word = "";
        const start3 = this.state.pos;
        let chunkStart = this.state.pos;
        if (firstCode !== void 0) {
          this.state.pos += firstCode <= 65535 ? 1 : 2;
        }
        while (this.state.pos < this.length) {
          const ch = this.codePointAtPos(this.state.pos);
          if (isIdentifierChar3(ch)) {
            this.state.pos += ch <= 65535 ? 1 : 2;
          } else if (ch === 92) {
            this.state.containsEsc = true;
            word += this.input.slice(chunkStart, this.state.pos);
            const escStart = this.state.curPosition();
            const identifierCheck = this.state.pos === start3 ? isIdentifierStart3 : isIdentifierChar3;
            if (this.input.charCodeAt(++this.state.pos) !== 117) {
              this.raise(Errors.MissingUnicodeEscape, {
                at: this.state.curPosition()
              });
              chunkStart = this.state.pos - 1;
              continue;
            }
            ++this.state.pos;
            const esc = this.readCodePoint(true);
            if (esc !== null) {
              if (!identifierCheck(esc)) {
                this.raise(Errors.EscapedCharNotAnIdentifier, {
                  at: escStart
                });
              }
              word += String.fromCodePoint(esc);
            }
            chunkStart = this.state.pos;
          } else {
            break;
          }
        }
        return word + this.input.slice(chunkStart, this.state.pos);
      }
      readWord(firstCode) {
        const word = this.readWord1(firstCode);
        const type = keywords$13.get(word);
        if (type !== void 0) {
          this.finishToken(type, tokenLabelName(type));
        } else {
          this.finishToken(130, word);
        }
      }
      checkKeywordEscapes() {
        const {
          type
        } = this.state;
        if (tokenIsKeyword(type) && this.state.containsEsc) {
          this.raise(Errors.InvalidEscapedReservedWord, {
            at: this.state.startLoc,
            reservedWord: tokenLabelName(type)
          });
        }
      }
      raise(toParseError, raiseProperties) {
        const {
          at: at3
        } = raiseProperties, details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
        const loc = at3 instanceof Position5 ? at3 : at3.loc.start;
        const error = toParseError({
          loc,
          details
        });
        if (!this.options.errorRecovery)
          throw error;
        if (!this.isLookahead)
          this.state.errors.push(error);
        return error;
      }
      raiseOverwrite(toParseError, raiseProperties) {
        const {
          at: at3
        } = raiseProperties, details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2);
        const loc = at3 instanceof Position5 ? at3 : at3.loc.start;
        const pos2 = loc.index;
        const errors = this.state.errors;
        for (let i = errors.length - 1; i >= 0; i--) {
          const error = errors[i];
          if (error.loc.index === pos2) {
            return errors[i] = toParseError({
              loc,
              details
            });
          }
          if (error.loc.index < pos2)
            break;
        }
        return this.raise(toParseError, raiseProperties);
      }
      updateContext(prevType) {
      }
      unexpected(loc, type) {
        throw this.raise(Errors.UnexpectedToken, {
          expected: type ? tokenLabelName(type) : null,
          at: loc != null ? loc : this.state.startLoc
        });
      }
      expectPlugin(pluginName, loc) {
        if (this.hasPlugin(pluginName)) {
          return true;
        }
        throw this.raise(Errors.MissingPlugin, {
          at: loc != null ? loc : this.state.startLoc,
          missingPlugin: [pluginName]
        });
      }
      expectOnePlugin(pluginNames) {
        if (!pluginNames.some((name2) => this.hasPlugin(name2))) {
          throw this.raise(Errors.MissingOneOfPlugins, {
            at: this.state.startLoc,
            missingPlugin: pluginNames
          });
        }
      }
      errorBuilder(error) {
        return (pos2, lineStart, curLine) => {
          this.raise(error, {
            at: buildPosition(pos2, lineStart, curLine)
          });
        };
      }
    };
    var ClassScope = class {
      constructor() {
        this.privateNames = /* @__PURE__ */ new Set();
        this.loneAccessors = /* @__PURE__ */ new Map();
        this.undefinedPrivateNames = /* @__PURE__ */ new Map();
      }
    };
    var ClassScopeHandler = class {
      constructor(parser) {
        this.parser = void 0;
        this.stack = [];
        this.undefinedPrivateNames = /* @__PURE__ */ new Map();
        this.parser = parser;
      }
      current() {
        return this.stack[this.stack.length - 1];
      }
      enter() {
        this.stack.push(new ClassScope());
      }
      exit() {
        const oldClassScope = this.stack.pop();
        const current3 = this.current();
        for (const [name2, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {
          if (current3) {
            if (!current3.undefinedPrivateNames.has(name2)) {
              current3.undefinedPrivateNames.set(name2, loc);
            }
          } else {
            this.parser.raise(Errors.InvalidPrivateFieldResolution, {
              at: loc,
              identifierName: name2
            });
          }
        }
      }
      declarePrivateName(name2, elementType, loc) {
        const {
          privateNames,
          loneAccessors,
          undefinedPrivateNames
        } = this.current();
        let redefined = privateNames.has(name2);
        if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {
          const accessor = redefined && loneAccessors.get(name2);
          if (accessor) {
            const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;
            const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;
            const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;
            const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;
            redefined = oldKind === newKind || oldStatic !== newStatic;
            if (!redefined)
              loneAccessors.delete(name2);
          } else if (!redefined) {
            loneAccessors.set(name2, elementType);
          }
        }
        if (redefined) {
          this.parser.raise(Errors.PrivateNameRedeclaration, {
            at: loc,
            identifierName: name2
          });
        }
        privateNames.add(name2);
        undefinedPrivateNames.delete(name2);
      }
      usePrivateName(name2, loc) {
        let classScope;
        for (classScope of this.stack) {
          if (classScope.privateNames.has(name2))
            return;
        }
        if (classScope) {
          classScope.undefinedPrivateNames.set(name2, loc);
        } else {
          this.parser.raise(Errors.InvalidPrivateFieldResolution, {
            at: loc,
            identifierName: name2
          });
        }
      }
    };
    var kExpression = 0;
    var kMaybeArrowParameterDeclaration = 1;
    var kMaybeAsyncArrowParameterDeclaration = 2;
    var kParameterDeclaration = 3;
    var ExpressionScope = class {
      constructor(type = kExpression) {
        this.type = void 0;
        this.type = type;
      }
      canBeArrowParameterDeclaration() {
        return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration;
      }
      isCertainlyParameterDeclaration() {
        return this.type === kParameterDeclaration;
      }
    };
    var ArrowHeadParsingScope = class extends ExpressionScope {
      constructor(type) {
        super(type);
        this.declarationErrors = /* @__PURE__ */ new Map();
      }
      recordDeclarationError(ParsingErrorClass, {
        at: at3
      }) {
        const index2 = at3.index;
        this.declarationErrors.set(index2, [ParsingErrorClass, at3]);
      }
      clearDeclarationError(index2) {
        this.declarationErrors.delete(index2);
      }
      iterateErrors(iterator) {
        this.declarationErrors.forEach(iterator);
      }
    };
    var ExpressionScopeHandler = class {
      constructor(parser) {
        this.parser = void 0;
        this.stack = [new ExpressionScope()];
        this.parser = parser;
      }
      enter(scope) {
        this.stack.push(scope);
      }
      exit() {
        this.stack.pop();
      }
      recordParameterInitializerError(toParseError, {
        at: node2
      }) {
        const origin = {
          at: node2.loc.start
        };
        const {
          stack: stack2
        } = this;
        let i = stack2.length - 1;
        let scope = stack2[i];
        while (!scope.isCertainlyParameterDeclaration()) {
          if (scope.canBeArrowParameterDeclaration()) {
            scope.recordDeclarationError(toParseError, origin);
          } else {
            return;
          }
          scope = stack2[--i];
        }
        this.parser.raise(toParseError, origin);
      }
      recordArrowParameterBindingError(error, {
        at: node2
      }) {
        const {
          stack: stack2
        } = this;
        const scope = stack2[stack2.length - 1];
        const origin = {
          at: node2.loc.start
        };
        if (scope.isCertainlyParameterDeclaration()) {
          this.parser.raise(error, origin);
        } else if (scope.canBeArrowParameterDeclaration()) {
          scope.recordDeclarationError(error, origin);
        } else {
          return;
        }
      }
      recordAsyncArrowParametersError({
        at: at3
      }) {
        const {
          stack: stack2
        } = this;
        let i = stack2.length - 1;
        let scope = stack2[i];
        while (scope.canBeArrowParameterDeclaration()) {
          if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
            scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
              at: at3
            });
          }
          scope = stack2[--i];
        }
      }
      validateAsPattern() {
        const {
          stack: stack2
        } = this;
        const currentScope = stack2[stack2.length - 1];
        if (!currentScope.canBeArrowParameterDeclaration())
          return;
        currentScope.iterateErrors(([toParseError, loc]) => {
          this.parser.raise(toParseError, {
            at: loc
          });
          let i = stack2.length - 2;
          let scope = stack2[i];
          while (scope.canBeArrowParameterDeclaration()) {
            scope.clearDeclarationError(loc.index);
            scope = stack2[--i];
          }
        });
      }
    };
    function newParameterDeclarationScope() {
      return new ExpressionScope(kParameterDeclaration);
    }
    function newArrowHeadScope() {
      return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
    }
    function newAsyncArrowScope() {
      return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
    }
    function newExpressionScope() {
      return new ExpressionScope();
    }
    var PARAM = 0;
    var PARAM_YIELD = 1;
    var PARAM_AWAIT = 2;
    var PARAM_RETURN = 4;
    var PARAM_IN = 8;
    var ProductionParameterHandler = class {
      constructor() {
        this.stacks = [];
      }
      enter(flags) {
        this.stacks.push(flags);
      }
      exit() {
        this.stacks.pop();
      }
      currentFlags() {
        return this.stacks[this.stacks.length - 1];
      }
      get hasAwait() {
        return (this.currentFlags() & PARAM_AWAIT) > 0;
      }
      get hasYield() {
        return (this.currentFlags() & PARAM_YIELD) > 0;
      }
      get hasReturn() {
        return (this.currentFlags() & PARAM_RETURN) > 0;
      }
      get hasIn() {
        return (this.currentFlags() & PARAM_IN) > 0;
      }
    };
    function functionFlags3(isAsync, isGenerator) {
      return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
    }
    var UtilParser = class extends Tokenizer {
      addExtra(node2, key2, value2, enumerable = true) {
        if (!node2)
          return;
        const extra = node2.extra = node2.extra || {};
        if (enumerable) {
          extra[key2] = value2;
        } else {
          Object.defineProperty(extra, key2, {
            enumerable,
            value: value2
          });
        }
      }
      isContextual(token2) {
        return this.state.type === token2 && !this.state.containsEsc;
      }
      isUnparsedContextual(nameStart, name2) {
        const nameEnd = nameStart + name2.length;
        if (this.input.slice(nameStart, nameEnd) === name2) {
          const nextCh = this.input.charCodeAt(nameEnd);
          return !(isIdentifierChar3(nextCh) || (nextCh & 64512) === 55296);
        }
        return false;
      }
      isLookaheadContextual(name2) {
        const next = this.nextTokenStart();
        return this.isUnparsedContextual(next, name2);
      }
      eatContextual(token2) {
        if (this.isContextual(token2)) {
          this.next();
          return true;
        }
        return false;
      }
      expectContextual(token2, toParseError) {
        if (!this.eatContextual(token2)) {
          if (toParseError != null) {
            throw this.raise(toParseError, {
              at: this.state.startLoc
            });
          }
          this.unexpected(null, token2);
        }
      }
      canInsertSemicolon() {
        return this.match(137) || this.match(8) || this.hasPrecedingLineBreak();
      }
      hasPrecedingLineBreak() {
        return lineBreak3.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start));
      }
      hasFollowingLineBreak() {
        skipWhiteSpaceToLineBreak.lastIndex = this.state.end;
        return skipWhiteSpaceToLineBreak.test(this.input);
      }
      isLineTerminator() {
        return this.eat(13) || this.canInsertSemicolon();
      }
      semicolon(allowAsi = true) {
        if (allowAsi ? this.isLineTerminator() : this.eat(13))
          return;
        this.raise(Errors.MissingSemicolon, {
          at: this.state.lastTokEndLoc
        });
      }
      expect(type, loc) {
        this.eat(type) || this.unexpected(loc, type);
      }
      tryParse(fn, oldState = this.state.clone()) {
        const abortSignal = {
          node: null
        };
        try {
          const node2 = fn((node3 = null) => {
            abortSignal.node = node3;
            throw abortSignal;
          });
          if (this.state.errors.length > oldState.errors.length) {
            const failState = this.state;
            this.state = oldState;
            this.state.tokensLength = failState.tokensLength;
            return {
              node: node2,
              error: failState.errors[oldState.errors.length],
              thrown: false,
              aborted: false,
              failState
            };
          }
          return {
            node: node2,
            error: null,
            thrown: false,
            aborted: false,
            failState: null
          };
        } catch (error) {
          const failState = this.state;
          this.state = oldState;
          if (error instanceof SyntaxError) {
            return {
              node: null,
              error,
              thrown: true,
              aborted: false,
              failState
            };
          }
          if (error === abortSignal) {
            return {
              node: abortSignal.node,
              error: null,
              thrown: false,
              aborted: true,
              failState
            };
          }
          throw error;
        }
      }
      checkExpressionErrors(refExpressionErrors, andThrow) {
        if (!refExpressionErrors)
          return false;
        const {
          shorthandAssignLoc,
          doubleProtoLoc,
          privateKeyLoc,
          optionalParametersLoc
        } = refExpressionErrors;
        const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc;
        if (!andThrow) {
          return hasErrors;
        }
        if (shorthandAssignLoc != null) {
          this.raise(Errors.InvalidCoverInitializedName, {
            at: shorthandAssignLoc
          });
        }
        if (doubleProtoLoc != null) {
          this.raise(Errors.DuplicateProto, {
            at: doubleProtoLoc
          });
        }
        if (privateKeyLoc != null) {
          this.raise(Errors.UnexpectedPrivateField, {
            at: privateKeyLoc
          });
        }
        if (optionalParametersLoc != null) {
          this.unexpected(optionalParametersLoc);
        }
      }
      isLiteralPropertyName() {
        return tokenIsLiteralPropertyName(this.state.type);
      }
      isPrivateName(node2) {
        return node2.type === "PrivateName";
      }
      getPrivateNameSV(node2) {
        return node2.id.name;
      }
      hasPropertyAsPrivateName(node2) {
        return (node2.type === "MemberExpression" || node2.type === "OptionalMemberExpression") && this.isPrivateName(node2.property);
      }
      isObjectProperty(node2) {
        return node2.type === "ObjectProperty";
      }
      isObjectMethod(node2) {
        return node2.type === "ObjectMethod";
      }
      initializeScopes(inModule = this.options.sourceType === "module") {
        const oldLabels = this.state.labels;
        this.state.labels = [];
        const oldExportedIdentifiers = this.exportedIdentifiers;
        this.exportedIdentifiers = /* @__PURE__ */ new Set();
        const oldInModule = this.inModule;
        this.inModule = inModule;
        const oldScope = this.scope;
        const ScopeHandler2 = this.getScopeHandler();
        this.scope = new ScopeHandler2(this, inModule);
        const oldProdParam = this.prodParam;
        this.prodParam = new ProductionParameterHandler();
        const oldClassScope = this.classScope;
        this.classScope = new ClassScopeHandler(this);
        const oldExpressionScope = this.expressionScope;
        this.expressionScope = new ExpressionScopeHandler(this);
        return () => {
          this.state.labels = oldLabels;
          this.exportedIdentifiers = oldExportedIdentifiers;
          this.inModule = oldInModule;
          this.scope = oldScope;
          this.prodParam = oldProdParam;
          this.classScope = oldClassScope;
          this.expressionScope = oldExpressionScope;
        };
      }
      enterInitialScopes() {
        let paramFlags = PARAM;
        if (this.inModule) {
          paramFlags |= PARAM_AWAIT;
        }
        this.scope.enter(SCOPE_PROGRAM);
        this.prodParam.enter(paramFlags);
      }
      checkDestructuringPrivate(refExpressionErrors) {
        const {
          privateKeyLoc
        } = refExpressionErrors;
        if (privateKeyLoc !== null) {
          this.expectPlugin("destructuringPrivate", privateKeyLoc);
        }
      }
    };
    var ExpressionErrors = class {
      constructor() {
        this.shorthandAssignLoc = null;
        this.doubleProtoLoc = null;
        this.privateKeyLoc = null;
        this.optionalParametersLoc = null;
      }
    };
    var Node5 = class {
      constructor(parser, pos2, loc) {
        this.type = "";
        this.start = pos2;
        this.end = 0;
        this.loc = new SourceLocation5(loc);
        if (parser != null && parser.options.ranges)
          this.range = [pos2, 0];
        if (parser != null && parser.filename)
          this.loc.filename = parser.filename;
      }
    };
    var NodePrototype = Node5.prototype;
    {
      NodePrototype.__clone = function() {
        const newNode = new Node5(void 0, this.start, this.loc.start);
        const keys2 = Object.keys(this);
        for (let i = 0, length = keys2.length; i < length; i++) {
          const key2 = keys2[i];
          if (key2 !== "leadingComments" && key2 !== "trailingComments" && key2 !== "innerComments") {
            newNode[key2] = this[key2];
          }
        }
        return newNode;
      };
    }
    function clonePlaceholder(node2) {
      return cloneIdentifier(node2);
    }
    function cloneIdentifier(node2) {
      const {
        type,
        start: start3,
        end,
        loc,
        range,
        extra,
        name: name2
      } = node2;
      const cloned = Object.create(NodePrototype);
      cloned.type = type;
      cloned.start = start3;
      cloned.end = end;
      cloned.loc = loc;
      cloned.range = range;
      cloned.extra = extra;
      cloned.name = name2;
      if (type === "Placeholder") {
        cloned.expectedNode = node2.expectedNode;
      }
      return cloned;
    }
    function cloneStringLiteral(node2) {
      const {
        type,
        start: start3,
        end,
        loc,
        range,
        extra
      } = node2;
      if (type === "Placeholder") {
        return clonePlaceholder(node2);
      }
      const cloned = Object.create(NodePrototype);
      cloned.type = type;
      cloned.start = start3;
      cloned.end = end;
      cloned.loc = loc;
      cloned.range = range;
      if (node2.raw !== void 0) {
        cloned.raw = node2.raw;
      } else {
        cloned.extra = extra;
      }
      cloned.value = node2.value;
      return cloned;
    }
    var NodeUtils = class extends UtilParser {
      startNode() {
        return new Node5(this, this.state.start, this.state.startLoc);
      }
      startNodeAt(loc) {
        return new Node5(this, loc.index, loc);
      }
      startNodeAtNode(type) {
        return this.startNodeAt(type.loc.start);
      }
      finishNode(node2, type) {
        return this.finishNodeAt(node2, type, this.state.lastTokEndLoc);
      }
      finishNodeAt(node2, type, endLoc) {
        node2.type = type;
        node2.end = endLoc.index;
        node2.loc.end = endLoc;
        if (this.options.ranges)
          node2.range[1] = endLoc.index;
        if (this.options.attachComment)
          this.processComment(node2);
        return node2;
      }
      resetStartLocation(node2, startLoc) {
        node2.start = startLoc.index;
        node2.loc.start = startLoc;
        if (this.options.ranges)
          node2.range[0] = startLoc.index;
      }
      resetEndLocation(node2, endLoc = this.state.lastTokEndLoc) {
        node2.end = endLoc.index;
        node2.loc.end = endLoc;
        if (this.options.ranges)
          node2.range[1] = endLoc.index;
      }
      resetStartLocationFromNode(node2, locationNode) {
        this.resetStartLocation(node2, locationNode.loc.start);
      }
    };
    var reservedTypes = /* @__PURE__ */ new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
    var FlowErrors = ParseErrorEnum`flow`({
      AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
      AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
      AssignReservedType: ({
        reservedType
      }) => `Cannot overwrite reserved type ${reservedType}.`,
      DeclareClassElement: "The `declare` modifier can only appear on class fields.",
      DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
      DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
      EnumBooleanMemberNotInitialized: ({
        memberName,
        enumName
      }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
      EnumDuplicateMemberName: ({
        memberName,
        enumName
      }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
      EnumInconsistentMemberValues: ({
        enumName
      }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
      EnumInvalidExplicitType: ({
        invalidEnumType,
        enumName
      }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
      EnumInvalidExplicitTypeUnknownSupplied: ({
        enumName
      }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
      EnumInvalidMemberInitializerPrimaryType: ({
        enumName,
        memberName,
        explicitType
      }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
      EnumInvalidMemberInitializerSymbolType: ({
        enumName,
        memberName
      }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
      EnumInvalidMemberInitializerUnknownType: ({
        enumName,
        memberName
      }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
      EnumInvalidMemberName: ({
        enumName,
        memberName,
        suggestion
      }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
      EnumNumberMemberNotInitialized: ({
        enumName,
        memberName
      }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
      EnumStringMemberInconsistentlyInitailized: ({
        enumName
      }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
      GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
      ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.",
      ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
      InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
      InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
      InexactVariance: "Explicit inexact syntax cannot have variance.",
      InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
      MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
      NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
      NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
      PatternIsOptional: Object.assign({
        message: "A binding pattern parameter cannot be optional in an implementation signature."
      }, {
        reasonCode: "OptionalBindingPattern"
      }),
      SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
      SpreadVariance: "Spread properties cannot have variance.",
      ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
      ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
      ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
      ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
      ThisParamNoDefault: "The `this` parameter may not have a default value.",
      TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
      TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
      UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
      UnexpectedReservedType: ({
        reservedType
      }) => `Unexpected reserved type ${reservedType}.`,
      UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
      UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
      UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
      UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".',
      UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
      UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
      UnsupportedDeclareExportKind: ({
        unsupportedExportKind,
        suggestion
      }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
      UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
      UnterminatedFlowComment: "Unterminated flow-comment."
    });
    function isEsModuleType(bodyElement) {
      return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
    }
    function hasTypeImportKind(node2) {
      return node2.importKind === "type" || node2.importKind === "typeof";
    }
    function isMaybeDefaultImport(type) {
      return tokenIsKeywordOrIdentifier(type) && type !== 97;
    }
    var exportSuggestions = {
      const: "declare export var",
      let: "declare export var",
      type: "export type",
      interface: "export interface"
    };
    function partition(list3, test) {
      const list1 = [];
      const list22 = [];
      for (let i = 0; i < list3.length; i++) {
        (test(list3[i], i, list3) ? list1 : list22).push(list3[i]);
      }
      return [list1, list22];
    }
    var FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
    var flow3 = (superClass) => class FlowParserMixin extends superClass {
      constructor(...args) {
        super(...args);
        this.flowPragma = void 0;
      }
      getScopeHandler() {
        return FlowScopeHandler;
      }
      shouldParseTypes() {
        return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
      }
      shouldParseEnums() {
        return !!this.getPluginOption("flow", "enums");
      }
      finishToken(type, val) {
        if (type !== 131 && type !== 13 && type !== 28) {
          if (this.flowPragma === void 0) {
            this.flowPragma = null;
          }
        }
        super.finishToken(type, val);
      }
      addComment(comment2) {
        if (this.flowPragma === void 0) {
          const matches = FLOW_PRAGMA_REGEX.exec(comment2.value);
          if (!matches)
            ;
          else if (matches[1] === "flow") {
            this.flowPragma = "flow";
          } else if (matches[1] === "noflow") {
            this.flowPragma = "noflow";
          } else {
            throw new Error("Unexpected flow pragma");
          }
        }
        super.addComment(comment2);
      }
      flowParseTypeInitialiser(tok) {
        const oldInType = this.state.inType;
        this.state.inType = true;
        this.expect(tok || 14);
        const type = this.flowParseType();
        this.state.inType = oldInType;
        return type;
      }
      flowParsePredicate() {
        const node2 = this.startNode();
        const moduloLoc = this.state.startLoc;
        this.next();
        this.expectContextual(108);
        if (this.state.lastTokStart > moduloLoc.index + 1) {
          this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
            at: moduloLoc
          });
        }
        if (this.eat(10)) {
          node2.value = super.parseExpression();
          this.expect(11);
          return this.finishNode(node2, "DeclaredPredicate");
        } else {
          return this.finishNode(node2, "InferredPredicate");
        }
      }
      flowParseTypeAndPredicateInitialiser() {
        const oldInType = this.state.inType;
        this.state.inType = true;
        this.expect(14);
        let type = null;
        let predicate = null;
        if (this.match(54)) {
          this.state.inType = oldInType;
          predicate = this.flowParsePredicate();
        } else {
          type = this.flowParseType();
          this.state.inType = oldInType;
          if (this.match(54)) {
            predicate = this.flowParsePredicate();
          }
        }
        return [type, predicate];
      }
      flowParseDeclareClass(node2) {
        this.next();
        this.flowParseInterfaceish(node2, true);
        return this.finishNode(node2, "DeclareClass");
      }
      flowParseDeclareFunction(node2) {
        this.next();
        const id = node2.id = this.parseIdentifier();
        const typeNode = this.startNode();
        const typeContainer = this.startNode();
        if (this.match(47)) {
          typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          typeNode.typeParameters = null;
        }
        this.expect(10);
        const tmp = this.flowParseFunctionTypeParams();
        typeNode.params = tmp.params;
        typeNode.rest = tmp.rest;
        typeNode.this = tmp._this;
        this.expect(11);
        [typeNode.returnType, node2.predicate] = this.flowParseTypeAndPredicateInitialiser();
        typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
        id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
        this.resetEndLocation(id);
        this.semicolon();
        this.scope.declareName(node2.id.name, BIND_FLOW_DECLARE_FN, node2.id.loc.start);
        return this.finishNode(node2, "DeclareFunction");
      }
      flowParseDeclare(node2, insideModule) {
        if (this.match(80)) {
          return this.flowParseDeclareClass(node2);
        } else if (this.match(68)) {
          return this.flowParseDeclareFunction(node2);
        } else if (this.match(74)) {
          return this.flowParseDeclareVariable(node2);
        } else if (this.eatContextual(125)) {
          if (this.match(16)) {
            return this.flowParseDeclareModuleExports(node2);
          } else {
            if (insideModule) {
              this.raise(FlowErrors.NestedDeclareModule, {
                at: this.state.lastTokStartLoc
              });
            }
            return this.flowParseDeclareModule(node2);
          }
        } else if (this.isContextual(128)) {
          return this.flowParseDeclareTypeAlias(node2);
        } else if (this.isContextual(129)) {
          return this.flowParseDeclareOpaqueType(node2);
        } else if (this.isContextual(127)) {
          return this.flowParseDeclareInterface(node2);
        } else if (this.match(82)) {
          return this.flowParseDeclareExportDeclaration(node2, insideModule);
        } else {
          this.unexpected();
        }
      }
      flowParseDeclareVariable(node2) {
        this.next();
        node2.id = this.flowParseTypeAnnotatableIdentifier(true);
        this.scope.declareName(node2.id.name, BIND_VAR3, node2.id.loc.start);
        this.semicolon();
        return this.finishNode(node2, "DeclareVariable");
      }
      flowParseDeclareModule(node2) {
        this.scope.enter(SCOPE_OTHER);
        if (this.match(131)) {
          node2.id = super.parseExprAtom();
        } else {
          node2.id = this.parseIdentifier();
        }
        const bodyNode = node2.body = this.startNode();
        const body = bodyNode.body = [];
        this.expect(5);
        while (!this.match(8)) {
          let bodyNode2 = this.startNode();
          if (this.match(83)) {
            this.next();
            if (!this.isContextual(128) && !this.match(87)) {
              this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
                at: this.state.lastTokStartLoc
              });
            }
            super.parseImport(bodyNode2);
          } else {
            this.expectContextual(123, FlowErrors.UnsupportedStatementInDeclareModule);
            bodyNode2 = this.flowParseDeclare(bodyNode2, true);
          }
          body.push(bodyNode2);
        }
        this.scope.exit();
        this.expect(8);
        this.finishNode(bodyNode, "BlockStatement");
        let kind = null;
        let hasModuleExport = false;
        body.forEach((bodyElement) => {
          if (isEsModuleType(bodyElement)) {
            if (kind === "CommonJS") {
              this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
                at: bodyElement
              });
            }
            kind = "ES";
          } else if (bodyElement.type === "DeclareModuleExports") {
            if (hasModuleExport) {
              this.raise(FlowErrors.DuplicateDeclareModuleExports, {
                at: bodyElement
              });
            }
            if (kind === "ES") {
              this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
                at: bodyElement
              });
            }
            kind = "CommonJS";
            hasModuleExport = true;
          }
        });
        node2.kind = kind || "CommonJS";
        return this.finishNode(node2, "DeclareModule");
      }
      flowParseDeclareExportDeclaration(node2, insideModule) {
        this.expect(82);
        if (this.eat(65)) {
          if (this.match(68) || this.match(80)) {
            node2.declaration = this.flowParseDeclare(this.startNode());
          } else {
            node2.declaration = this.flowParseType();
            this.semicolon();
          }
          node2.default = true;
          return this.finishNode(node2, "DeclareExportDeclaration");
        } else {
          if (this.match(75) || this.isLet() || (this.isContextual(128) || this.isContextual(127)) && !insideModule) {
            const label = this.state.value;
            throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
              at: this.state.startLoc,
              unsupportedExportKind: label,
              suggestion: exportSuggestions[label]
            });
          }
          if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(129)) {
            node2.declaration = this.flowParseDeclare(this.startNode());
            node2.default = false;
            return this.finishNode(node2, "DeclareExportDeclaration");
          } else if (this.match(55) || this.match(5) || this.isContextual(127) || this.isContextual(128) || this.isContextual(129)) {
            node2 = this.parseExport(node2, null);
            if (node2.type === "ExportNamedDeclaration") {
              node2.type = "ExportDeclaration";
              node2.default = false;
              delete node2.exportKind;
            }
            node2.type = "Declare" + node2.type;
            return node2;
          }
        }
        this.unexpected();
      }
      flowParseDeclareModuleExports(node2) {
        this.next();
        this.expectContextual(109);
        node2.typeAnnotation = this.flowParseTypeAnnotation();
        this.semicolon();
        return this.finishNode(node2, "DeclareModuleExports");
      }
      flowParseDeclareTypeAlias(node2) {
        this.next();
        const finished = this.flowParseTypeAlias(node2);
        finished.type = "DeclareTypeAlias";
        return finished;
      }
      flowParseDeclareOpaqueType(node2) {
        this.next();
        const finished = this.flowParseOpaqueType(node2, true);
        finished.type = "DeclareOpaqueType";
        return finished;
      }
      flowParseDeclareInterface(node2) {
        this.next();
        this.flowParseInterfaceish(node2, false);
        return this.finishNode(node2, "DeclareInterface");
      }
      flowParseInterfaceish(node2, isClass) {
        node2.id = this.flowParseRestrictedIdentifier(!isClass, true);
        this.scope.declareName(node2.id.name, isClass ? BIND_FUNCTION3 : BIND_LEXICAL3, node2.id.loc.start);
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          node2.typeParameters = null;
        }
        node2.extends = [];
        node2.implements = [];
        node2.mixins = [];
        if (this.eat(81)) {
          do {
            node2.extends.push(this.flowParseInterfaceExtends());
          } while (!isClass && this.eat(12));
        }
        if (isClass) {
          if (this.eatContextual(115)) {
            do {
              node2.mixins.push(this.flowParseInterfaceExtends());
            } while (this.eat(12));
          }
          if (this.eatContextual(111)) {
            do {
              node2.implements.push(this.flowParseInterfaceExtends());
            } while (this.eat(12));
          }
        }
        node2.body = this.flowParseObjectType({
          allowStatic: isClass,
          allowExact: false,
          allowSpread: false,
          allowProto: isClass,
          allowInexact: false
        });
      }
      flowParseInterfaceExtends() {
        const node2 = this.startNode();
        node2.id = this.flowParseQualifiedTypeIdentifier();
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterInstantiation();
        } else {
          node2.typeParameters = null;
        }
        return this.finishNode(node2, "InterfaceExtends");
      }
      flowParseInterface(node2) {
        this.flowParseInterfaceish(node2, false);
        return this.finishNode(node2, "InterfaceDeclaration");
      }
      checkNotUnderscore(word) {
        if (word === "_") {
          this.raise(FlowErrors.UnexpectedReservedUnderscore, {
            at: this.state.startLoc
          });
        }
      }
      checkReservedType(word, startLoc, declaration) {
        if (!reservedTypes.has(word))
          return;
        this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, {
          at: startLoc,
          reservedType: word
        });
      }
      flowParseRestrictedIdentifier(liberal, declaration) {
        this.checkReservedType(this.state.value, this.state.startLoc, declaration);
        return this.parseIdentifier(liberal);
      }
      flowParseTypeAlias(node2) {
        node2.id = this.flowParseRestrictedIdentifier(false, true);
        this.scope.declareName(node2.id.name, BIND_LEXICAL3, node2.id.loc.start);
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          node2.typeParameters = null;
        }
        node2.right = this.flowParseTypeInitialiser(29);
        this.semicolon();
        return this.finishNode(node2, "TypeAlias");
      }
      flowParseOpaqueType(node2, declare) {
        this.expectContextual(128);
        node2.id = this.flowParseRestrictedIdentifier(true, true);
        this.scope.declareName(node2.id.name, BIND_LEXICAL3, node2.id.loc.start);
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          node2.typeParameters = null;
        }
        node2.supertype = null;
        if (this.match(14)) {
          node2.supertype = this.flowParseTypeInitialiser(14);
        }
        node2.impltype = null;
        if (!declare) {
          node2.impltype = this.flowParseTypeInitialiser(29);
        }
        this.semicolon();
        return this.finishNode(node2, "OpaqueType");
      }
      flowParseTypeParameter(requireDefault = false) {
        const nodeStartLoc = this.state.startLoc;
        const node2 = this.startNode();
        const variance = this.flowParseVariance();
        const ident = this.flowParseTypeAnnotatableIdentifier();
        node2.name = ident.name;
        node2.variance = variance;
        node2.bound = ident.typeAnnotation;
        if (this.match(29)) {
          this.eat(29);
          node2.default = this.flowParseType();
        } else {
          if (requireDefault) {
            this.raise(FlowErrors.MissingTypeParamDefault, {
              at: nodeStartLoc
            });
          }
        }
        return this.finishNode(node2, "TypeParameter");
      }
      flowParseTypeParameterDeclaration() {
        const oldInType = this.state.inType;
        const node2 = this.startNode();
        node2.params = [];
        this.state.inType = true;
        if (this.match(47) || this.match(140)) {
          this.next();
        } else {
          this.unexpected();
        }
        let defaultRequired = false;
        do {
          const typeParameter = this.flowParseTypeParameter(defaultRequired);
          node2.params.push(typeParameter);
          if (typeParameter.default) {
            defaultRequired = true;
          }
          if (!this.match(48)) {
            this.expect(12);
          }
        } while (!this.match(48));
        this.expect(48);
        this.state.inType = oldInType;
        return this.finishNode(node2, "TypeParameterDeclaration");
      }
      flowParseTypeParameterInstantiation() {
        const node2 = this.startNode();
        const oldInType = this.state.inType;
        node2.params = [];
        this.state.inType = true;
        this.expect(47);
        const oldNoAnonFunctionType = this.state.noAnonFunctionType;
        this.state.noAnonFunctionType = false;
        while (!this.match(48)) {
          node2.params.push(this.flowParseType());
          if (!this.match(48)) {
            this.expect(12);
          }
        }
        this.state.noAnonFunctionType = oldNoAnonFunctionType;
        this.expect(48);
        this.state.inType = oldInType;
        return this.finishNode(node2, "TypeParameterInstantiation");
      }
      flowParseTypeParameterInstantiationCallOrNew() {
        const node2 = this.startNode();
        const oldInType = this.state.inType;
        node2.params = [];
        this.state.inType = true;
        this.expect(47);
        while (!this.match(48)) {
          node2.params.push(this.flowParseTypeOrImplicitInstantiation());
          if (!this.match(48)) {
            this.expect(12);
          }
        }
        this.expect(48);
        this.state.inType = oldInType;
        return this.finishNode(node2, "TypeParameterInstantiation");
      }
      flowParseInterfaceType() {
        const node2 = this.startNode();
        this.expectContextual(127);
        node2.extends = [];
        if (this.eat(81)) {
          do {
            node2.extends.push(this.flowParseInterfaceExtends());
          } while (this.eat(12));
        }
        node2.body = this.flowParseObjectType({
          allowStatic: false,
          allowExact: false,
          allowSpread: false,
          allowProto: false,
          allowInexact: false
        });
        return this.finishNode(node2, "InterfaceTypeAnnotation");
      }
      flowParseObjectPropertyKey() {
        return this.match(132) || this.match(131) ? super.parseExprAtom() : this.parseIdentifier(true);
      }
      flowParseObjectTypeIndexer(node2, isStatic, variance) {
        node2.static = isStatic;
        if (this.lookahead().type === 14) {
          node2.id = this.flowParseObjectPropertyKey();
          node2.key = this.flowParseTypeInitialiser();
        } else {
          node2.id = null;
          node2.key = this.flowParseType();
        }
        this.expect(3);
        node2.value = this.flowParseTypeInitialiser();
        node2.variance = variance;
        return this.finishNode(node2, "ObjectTypeIndexer");
      }
      flowParseObjectTypeInternalSlot(node2, isStatic) {
        node2.static = isStatic;
        node2.id = this.flowParseObjectPropertyKey();
        this.expect(3);
        this.expect(3);
        if (this.match(47) || this.match(10)) {
          node2.method = true;
          node2.optional = false;
          node2.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node2.loc.start));
        } else {
          node2.method = false;
          if (this.eat(17)) {
            node2.optional = true;
          }
          node2.value = this.flowParseTypeInitialiser();
        }
        return this.finishNode(node2, "ObjectTypeInternalSlot");
      }
      flowParseObjectTypeMethodish(node2) {
        node2.params = [];
        node2.rest = null;
        node2.typeParameters = null;
        node2.this = null;
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterDeclaration();
        }
        this.expect(10);
        if (this.match(78)) {
          node2.this = this.flowParseFunctionTypeParam(true);
          node2.this.name = null;
          if (!this.match(11)) {
            this.expect(12);
          }
        }
        while (!this.match(11) && !this.match(21)) {
          node2.params.push(this.flowParseFunctionTypeParam(false));
          if (!this.match(11)) {
            this.expect(12);
          }
        }
        if (this.eat(21)) {
          node2.rest = this.flowParseFunctionTypeParam(false);
        }
        this.expect(11);
        node2.returnType = this.flowParseTypeInitialiser();
        return this.finishNode(node2, "FunctionTypeAnnotation");
      }
      flowParseObjectTypeCallProperty(node2, isStatic) {
        const valueNode = this.startNode();
        node2.static = isStatic;
        node2.value = this.flowParseObjectTypeMethodish(valueNode);
        return this.finishNode(node2, "ObjectTypeCallProperty");
      }
      flowParseObjectType({
        allowStatic,
        allowExact,
        allowSpread,
        allowProto,
        allowInexact
      }) {
        const oldInType = this.state.inType;
        this.state.inType = true;
        const nodeStart = this.startNode();
        nodeStart.callProperties = [];
        nodeStart.properties = [];
        nodeStart.indexers = [];
        nodeStart.internalSlots = [];
        let endDelim;
        let exact;
        let inexact = false;
        if (allowExact && this.match(6)) {
          this.expect(6);
          endDelim = 9;
          exact = true;
        } else {
          this.expect(5);
          endDelim = 8;
          exact = false;
        }
        nodeStart.exact = exact;
        while (!this.match(endDelim)) {
          let isStatic = false;
          let protoStartLoc = null;
          let inexactStartLoc = null;
          const node2 = this.startNode();
          if (allowProto && this.isContextual(116)) {
            const lookahead3 = this.lookahead();
            if (lookahead3.type !== 14 && lookahead3.type !== 17) {
              this.next();
              protoStartLoc = this.state.startLoc;
              allowStatic = false;
            }
          }
          if (allowStatic && this.isContextual(104)) {
            const lookahead3 = this.lookahead();
            if (lookahead3.type !== 14 && lookahead3.type !== 17) {
              this.next();
              isStatic = true;
            }
          }
          const variance = this.flowParseVariance();
          if (this.eat(0)) {
            if (protoStartLoc != null) {
              this.unexpected(protoStartLoc);
            }
            if (this.eat(0)) {
              if (variance) {
                this.unexpected(variance.loc.start);
              }
              nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node2, isStatic));
            } else {
              nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node2, isStatic, variance));
            }
          } else if (this.match(10) || this.match(47)) {
            if (protoStartLoc != null) {
              this.unexpected(protoStartLoc);
            }
            if (variance) {
              this.unexpected(variance.loc.start);
            }
            nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node2, isStatic));
          } else {
            let kind = "init";
            if (this.isContextual(98) || this.isContextual(103)) {
              const lookahead3 = this.lookahead();
              if (tokenIsLiteralPropertyName(lookahead3.type)) {
                kind = this.state.value;
                this.next();
              }
            }
            const propOrInexact = this.flowParseObjectTypeProperty(node2, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
            if (propOrInexact === null) {
              inexact = true;
              inexactStartLoc = this.state.lastTokStartLoc;
            } else {
              nodeStart.properties.push(propOrInexact);
            }
          }
          this.flowObjectTypeSemicolon();
          if (inexactStartLoc && !this.match(8) && !this.match(9)) {
            this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
              at: inexactStartLoc
            });
          }
        }
        this.expect(endDelim);
        if (allowSpread) {
          nodeStart.inexact = inexact;
        }
        const out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
        this.state.inType = oldInType;
        return out;
      }
      flowParseObjectTypeProperty(node2, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
        if (this.eat(21)) {
          const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
          if (isInexactToken) {
            if (!allowSpread) {
              this.raise(FlowErrors.InexactInsideNonObject, {
                at: this.state.lastTokStartLoc
              });
            } else if (!allowInexact) {
              this.raise(FlowErrors.InexactInsideExact, {
                at: this.state.lastTokStartLoc
              });
            }
            if (variance) {
              this.raise(FlowErrors.InexactVariance, {
                at: variance
              });
            }
            return null;
          }
          if (!allowSpread) {
            this.raise(FlowErrors.UnexpectedSpreadType, {
              at: this.state.lastTokStartLoc
            });
          }
          if (protoStartLoc != null) {
            this.unexpected(protoStartLoc);
          }
          if (variance) {
            this.raise(FlowErrors.SpreadVariance, {
              at: variance
            });
          }
          node2.argument = this.flowParseType();
          return this.finishNode(node2, "ObjectTypeSpreadProperty");
        } else {
          node2.key = this.flowParseObjectPropertyKey();
          node2.static = isStatic;
          node2.proto = protoStartLoc != null;
          node2.kind = kind;
          let optional = false;
          if (this.match(47) || this.match(10)) {
            node2.method = true;
            if (protoStartLoc != null) {
              this.unexpected(protoStartLoc);
            }
            if (variance) {
              this.unexpected(variance.loc.start);
            }
            node2.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node2.loc.start));
            if (kind === "get" || kind === "set") {
              this.flowCheckGetterSetterParams(node2);
            }
            if (!allowSpread && node2.key.name === "constructor" && node2.value.this) {
              this.raise(FlowErrors.ThisParamBannedInConstructor, {
                at: node2.value.this
              });
            }
          } else {
            if (kind !== "init")
              this.unexpected();
            node2.method = false;
            if (this.eat(17)) {
              optional = true;
            }
            node2.value = this.flowParseTypeInitialiser();
            node2.variance = variance;
          }
          node2.optional = optional;
          return this.finishNode(node2, "ObjectTypeProperty");
        }
      }
      flowCheckGetterSetterParams(property) {
        const paramCount = property.kind === "get" ? 0 : 1;
        const length = property.value.params.length + (property.value.rest ? 1 : 0);
        if (property.value.this) {
          this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, {
            at: property.value.this
          });
        }
        if (length !== paramCount) {
          this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
            at: property
          });
        }
        if (property.kind === "set" && property.value.rest) {
          this.raise(Errors.BadSetterRestParameter, {
            at: property
          });
        }
      }
      flowObjectTypeSemicolon() {
        if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
          this.unexpected();
        }
      }
      flowParseQualifiedTypeIdentifier(startLoc, id) {
        var _startLoc;
        (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
        let node2 = id || this.flowParseRestrictedIdentifier(true);
        while (this.eat(16)) {
          const node22 = this.startNodeAt(startLoc);
          node22.qualification = node2;
          node22.id = this.flowParseRestrictedIdentifier(true);
          node2 = this.finishNode(node22, "QualifiedTypeIdentifier");
        }
        return node2;
      }
      flowParseGenericType(startLoc, id) {
        const node2 = this.startNodeAt(startLoc);
        node2.typeParameters = null;
        node2.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterInstantiation();
        }
        return this.finishNode(node2, "GenericTypeAnnotation");
      }
      flowParseTypeofType() {
        const node2 = this.startNode();
        this.expect(87);
        node2.argument = this.flowParsePrimaryType();
        return this.finishNode(node2, "TypeofTypeAnnotation");
      }
      flowParseTupleType() {
        const node2 = this.startNode();
        node2.types = [];
        this.expect(0);
        while (this.state.pos < this.length && !this.match(3)) {
          node2.types.push(this.flowParseType());
          if (this.match(3))
            break;
          this.expect(12);
        }
        this.expect(3);
        return this.finishNode(node2, "TupleTypeAnnotation");
      }
      flowParseFunctionTypeParam(first) {
        let name2 = null;
        let optional = false;
        let typeAnnotation = null;
        const node2 = this.startNode();
        const lh = this.lookahead();
        const isThis = this.state.type === 78;
        if (lh.type === 14 || lh.type === 17) {
          if (isThis && !first) {
            this.raise(FlowErrors.ThisParamMustBeFirst, {
              at: node2
            });
          }
          name2 = this.parseIdentifier(isThis);
          if (this.eat(17)) {
            optional = true;
            if (isThis) {
              this.raise(FlowErrors.ThisParamMayNotBeOptional, {
                at: node2
              });
            }
          }
          typeAnnotation = this.flowParseTypeInitialiser();
        } else {
          typeAnnotation = this.flowParseType();
        }
        node2.name = name2;
        node2.optional = optional;
        node2.typeAnnotation = typeAnnotation;
        return this.finishNode(node2, "FunctionTypeParam");
      }
      reinterpretTypeAsFunctionTypeParam(type) {
        const node2 = this.startNodeAt(type.loc.start);
        node2.name = null;
        node2.optional = false;
        node2.typeAnnotation = type;
        return this.finishNode(node2, "FunctionTypeParam");
      }
      flowParseFunctionTypeParams(params = []) {
        let rest = null;
        let _this = null;
        if (this.match(78)) {
          _this = this.flowParseFunctionTypeParam(true);
          _this.name = null;
          if (!this.match(11)) {
            this.expect(12);
          }
        }
        while (!this.match(11) && !this.match(21)) {
          params.push(this.flowParseFunctionTypeParam(false));
          if (!this.match(11)) {
            this.expect(12);
          }
        }
        if (this.eat(21)) {
          rest = this.flowParseFunctionTypeParam(false);
        }
        return {
          params,
          rest,
          _this
        };
      }
      flowIdentToTypeAnnotation(startLoc, node2, id) {
        switch (id.name) {
          case "any":
            return this.finishNode(node2, "AnyTypeAnnotation");
          case "bool":
          case "boolean":
            return this.finishNode(node2, "BooleanTypeAnnotation");
          case "mixed":
            return this.finishNode(node2, "MixedTypeAnnotation");
          case "empty":
            return this.finishNode(node2, "EmptyTypeAnnotation");
          case "number":
            return this.finishNode(node2, "NumberTypeAnnotation");
          case "string":
            return this.finishNode(node2, "StringTypeAnnotation");
          case "symbol":
            return this.finishNode(node2, "SymbolTypeAnnotation");
          default:
            this.checkNotUnderscore(id.name);
            return this.flowParseGenericType(startLoc, id);
        }
      }
      flowParsePrimaryType() {
        const startLoc = this.state.startLoc;
        const node2 = this.startNode();
        let tmp;
        let type;
        let isGroupedType = false;
        const oldNoAnonFunctionType = this.state.noAnonFunctionType;
        switch (this.state.type) {
          case 5:
            return this.flowParseObjectType({
              allowStatic: false,
              allowExact: false,
              allowSpread: true,
              allowProto: false,
              allowInexact: true
            });
          case 6:
            return this.flowParseObjectType({
              allowStatic: false,
              allowExact: true,
              allowSpread: true,
              allowProto: false,
              allowInexact: false
            });
          case 0:
            this.state.noAnonFunctionType = false;
            type = this.flowParseTupleType();
            this.state.noAnonFunctionType = oldNoAnonFunctionType;
            return type;
          case 47:
            node2.typeParameters = this.flowParseTypeParameterDeclaration();
            this.expect(10);
            tmp = this.flowParseFunctionTypeParams();
            node2.params = tmp.params;
            node2.rest = tmp.rest;
            node2.this = tmp._this;
            this.expect(11);
            this.expect(19);
            node2.returnType = this.flowParseType();
            return this.finishNode(node2, "FunctionTypeAnnotation");
          case 10:
            this.next();
            if (!this.match(11) && !this.match(21)) {
              if (tokenIsIdentifier(this.state.type) || this.match(78)) {
                const token2 = this.lookahead().type;
                isGroupedType = token2 !== 17 && token2 !== 14;
              } else {
                isGroupedType = true;
              }
            }
            if (isGroupedType) {
              this.state.noAnonFunctionType = false;
              type = this.flowParseType();
              this.state.noAnonFunctionType = oldNoAnonFunctionType;
              if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
                this.expect(11);
                return type;
              } else {
                this.eat(12);
              }
            }
            if (type) {
              tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
            } else {
              tmp = this.flowParseFunctionTypeParams();
            }
            node2.params = tmp.params;
            node2.rest = tmp.rest;
            node2.this = tmp._this;
            this.expect(11);
            this.expect(19);
            node2.returnType = this.flowParseType();
            node2.typeParameters = null;
            return this.finishNode(node2, "FunctionTypeAnnotation");
          case 131:
            return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
          case 85:
          case 86:
            node2.value = this.match(85);
            this.next();
            return this.finishNode(node2, "BooleanLiteralTypeAnnotation");
          case 53:
            if (this.state.value === "-") {
              this.next();
              if (this.match(132)) {
                return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node2);
              }
              if (this.match(133)) {
                return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node2);
              }
              throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
                at: this.state.startLoc
              });
            }
            this.unexpected();
            return;
          case 132:
            return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
          case 133:
            return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
          case 88:
            this.next();
            return this.finishNode(node2, "VoidTypeAnnotation");
          case 84:
            this.next();
            return this.finishNode(node2, "NullLiteralTypeAnnotation");
          case 78:
            this.next();
            return this.finishNode(node2, "ThisTypeAnnotation");
          case 55:
            this.next();
            return this.finishNode(node2, "ExistsTypeAnnotation");
          case 87:
            return this.flowParseTypeofType();
          default:
            if (tokenIsKeyword(this.state.type)) {
              const label = tokenLabelName(this.state.type);
              this.next();
              return super.createIdentifier(node2, label);
            } else if (tokenIsIdentifier(this.state.type)) {
              if (this.isContextual(127)) {
                return this.flowParseInterfaceType();
              }
              return this.flowIdentToTypeAnnotation(startLoc, node2, this.parseIdentifier());
            }
        }
        this.unexpected();
      }
      flowParsePostfixType() {
        const startLoc = this.state.startLoc;
        let type = this.flowParsePrimaryType();
        let seenOptionalIndexedAccess = false;
        while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
          const node2 = this.startNodeAt(startLoc);
          const optional = this.eat(18);
          seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
          this.expect(0);
          if (!optional && this.match(3)) {
            node2.elementType = type;
            this.next();
            type = this.finishNode(node2, "ArrayTypeAnnotation");
          } else {
            node2.objectType = type;
            node2.indexType = this.flowParseType();
            this.expect(3);
            if (seenOptionalIndexedAccess) {
              node2.optional = optional;
              type = this.finishNode(node2, "OptionalIndexedAccessType");
            } else {
              type = this.finishNode(node2, "IndexedAccessType");
            }
          }
        }
        return type;
      }
      flowParsePrefixType() {
        const node2 = this.startNode();
        if (this.eat(17)) {
          node2.typeAnnotation = this.flowParsePrefixType();
          return this.finishNode(node2, "NullableTypeAnnotation");
        } else {
          return this.flowParsePostfixType();
        }
      }
      flowParseAnonFunctionWithoutParens() {
        const param = this.flowParsePrefixType();
        if (!this.state.noAnonFunctionType && this.eat(19)) {
          const node2 = this.startNodeAt(param.loc.start);
          node2.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
          node2.rest = null;
          node2.this = null;
          node2.returnType = this.flowParseType();
          node2.typeParameters = null;
          return this.finishNode(node2, "FunctionTypeAnnotation");
        }
        return param;
      }
      flowParseIntersectionType() {
        const node2 = this.startNode();
        this.eat(45);
        const type = this.flowParseAnonFunctionWithoutParens();
        node2.types = [type];
        while (this.eat(45)) {
          node2.types.push(this.flowParseAnonFunctionWithoutParens());
        }
        return node2.types.length === 1 ? type : this.finishNode(node2, "IntersectionTypeAnnotation");
      }
      flowParseUnionType() {
        const node2 = this.startNode();
        this.eat(43);
        const type = this.flowParseIntersectionType();
        node2.types = [type];
        while (this.eat(43)) {
          node2.types.push(this.flowParseIntersectionType());
        }
        return node2.types.length === 1 ? type : this.finishNode(node2, "UnionTypeAnnotation");
      }
      flowParseType() {
        const oldInType = this.state.inType;
        this.state.inType = true;
        const type = this.flowParseUnionType();
        this.state.inType = oldInType;
        return type;
      }
      flowParseTypeOrImplicitInstantiation() {
        if (this.state.type === 130 && this.state.value === "_") {
          const startLoc = this.state.startLoc;
          const node2 = this.parseIdentifier();
          return this.flowParseGenericType(startLoc, node2);
        } else {
          return this.flowParseType();
        }
      }
      flowParseTypeAnnotation() {
        const node2 = this.startNode();
        node2.typeAnnotation = this.flowParseTypeInitialiser();
        return this.finishNode(node2, "TypeAnnotation");
      }
      flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
        const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
        if (this.match(14)) {
          ident.typeAnnotation = this.flowParseTypeAnnotation();
          this.resetEndLocation(ident);
        }
        return ident;
      }
      typeCastToParameter(node2) {
        node2.expression.typeAnnotation = node2.typeAnnotation;
        this.resetEndLocation(node2.expression, node2.typeAnnotation.loc.end);
        return node2.expression;
      }
      flowParseVariance() {
        let variance = null;
        if (this.match(53)) {
          variance = this.startNode();
          if (this.state.value === "+") {
            variance.kind = "plus";
          } else {
            variance.kind = "minus";
          }
          this.next();
          return this.finishNode(variance, "Variance");
        }
        return variance;
      }
      parseFunctionBody(node2, allowExpressionBody, isMethod = false) {
        if (allowExpressionBody) {
          this.forwardNoArrowParamsConversionAt(node2, () => super.parseFunctionBody(node2, true, isMethod));
          return;
        }
        super.parseFunctionBody(node2, false, isMethod);
      }
      parseFunctionBodyAndFinish(node2, type, isMethod = false) {
        if (this.match(14)) {
          const typeNode = this.startNode();
          [typeNode.typeAnnotation, node2.predicate] = this.flowParseTypeAndPredicateInitialiser();
          node2.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
        }
        return super.parseFunctionBodyAndFinish(node2, type, isMethod);
      }
      parseStatementLike(flags) {
        if (this.state.strict && this.isContextual(127)) {
          const lookahead3 = this.lookahead();
          if (tokenIsKeywordOrIdentifier(lookahead3.type)) {
            const node2 = this.startNode();
            this.next();
            return this.flowParseInterface(node2);
          }
        } else if (this.shouldParseEnums() && this.isContextual(124)) {
          const node2 = this.startNode();
          this.next();
          return this.flowParseEnumDeclaration(node2);
        }
        const stmt = super.parseStatementLike(flags);
        if (this.flowPragma === void 0 && !this.isValidDirective(stmt)) {
          this.flowPragma = null;
        }
        return stmt;
      }
      parseExpressionStatement(node2, expr, decorators) {
        if (expr.type === "Identifier") {
          if (expr.name === "declare") {
            if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
              return this.flowParseDeclare(node2);
            }
          } else if (tokenIsIdentifier(this.state.type)) {
            if (expr.name === "interface") {
              return this.flowParseInterface(node2);
            } else if (expr.name === "type") {
              return this.flowParseTypeAlias(node2);
            } else if (expr.name === "opaque") {
              return this.flowParseOpaqueType(node2, false);
            }
          }
        }
        return super.parseExpressionStatement(node2, expr, decorators);
      }
      shouldParseExportDeclaration() {
        const {
          type
        } = this.state;
        if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 124) {
          return !this.state.containsEsc;
        }
        return super.shouldParseExportDeclaration();
      }
      isExportDefaultSpecifier() {
        const {
          type
        } = this.state;
        if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 124) {
          return this.state.containsEsc;
        }
        return super.isExportDefaultSpecifier();
      }
      parseExportDefaultExpression() {
        if (this.shouldParseEnums() && this.isContextual(124)) {
          const node2 = this.startNode();
          this.next();
          return this.flowParseEnumDeclaration(node2);
        }
        return super.parseExportDefaultExpression();
      }
      parseConditional(expr, startLoc, refExpressionErrors) {
        if (!this.match(17))
          return expr;
        if (this.state.maybeInArrowParameters) {
          const nextCh = this.lookaheadCharCode();
          if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
            this.setOptionalParametersError(refExpressionErrors);
            return expr;
          }
        }
        this.expect(17);
        const state = this.state.clone();
        const originalNoArrowAt = this.state.noArrowAt;
        const node2 = this.startNodeAt(startLoc);
        let {
          consequent,
          failed
        } = this.tryParseConditionalConsequent();
        let [valid2, invalid2] = this.getArrowLikeExpressions(consequent);
        if (failed || invalid2.length > 0) {
          const noArrowAt = [...originalNoArrowAt];
          if (invalid2.length > 0) {
            this.state = state;
            this.state.noArrowAt = noArrowAt;
            for (let i = 0; i < invalid2.length; i++) {
              noArrowAt.push(invalid2[i].start);
            }
            ({
              consequent,
              failed
            } = this.tryParseConditionalConsequent());
            [valid2, invalid2] = this.getArrowLikeExpressions(consequent);
          }
          if (failed && valid2.length > 1) {
            this.raise(FlowErrors.AmbiguousConditionalArrow, {
              at: state.startLoc
            });
          }
          if (failed && valid2.length === 1) {
            this.state = state;
            noArrowAt.push(valid2[0].start);
            this.state.noArrowAt = noArrowAt;
            ({
              consequent,
              failed
            } = this.tryParseConditionalConsequent());
          }
        }
        this.getArrowLikeExpressions(consequent, true);
        this.state.noArrowAt = originalNoArrowAt;
        this.expect(14);
        node2.test = expr;
        node2.consequent = consequent;
        node2.alternate = this.forwardNoArrowParamsConversionAt(node2, () => this.parseMaybeAssign(void 0, void 0));
        return this.finishNode(node2, "ConditionalExpression");
      }
      tryParseConditionalConsequent() {
        this.state.noArrowParamsConversionAt.push(this.state.start);
        const consequent = this.parseMaybeAssignAllowIn();
        const failed = !this.match(14);
        this.state.noArrowParamsConversionAt.pop();
        return {
          consequent,
          failed
        };
      }
      getArrowLikeExpressions(node2, disallowInvalid) {
        const stack2 = [node2];
        const arrows = [];
        while (stack2.length !== 0) {
          const node3 = stack2.pop();
          if (node3.type === "ArrowFunctionExpression") {
            if (node3.typeParameters || !node3.returnType) {
              this.finishArrowValidation(node3);
            } else {
              arrows.push(node3);
            }
            stack2.push(node3.body);
          } else if (node3.type === "ConditionalExpression") {
            stack2.push(node3.consequent);
            stack2.push(node3.alternate);
          }
        }
        if (disallowInvalid) {
          arrows.forEach((node3) => this.finishArrowValidation(node3));
          return [arrows, []];
        }
        return partition(arrows, (node3) => node3.params.every((param) => this.isAssignable(param, true)));
      }
      finishArrowValidation(node2) {
        var _node$extra;
        this.toAssignableList(node2.params, (_node$extra = node2.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
        this.scope.enter(SCOPE_FUNCTION3 | SCOPE_ARROW3);
        super.checkParams(node2, false, true);
        this.scope.exit();
      }
      forwardNoArrowParamsConversionAt(node2, parse10) {
        let result;
        if (this.state.noArrowParamsConversionAt.indexOf(node2.start) !== -1) {
          this.state.noArrowParamsConversionAt.push(this.state.start);
          result = parse10();
          this.state.noArrowParamsConversionAt.pop();
        } else {
          result = parse10();
        }
        return result;
      }
      parseParenItem(node2, startLoc) {
        node2 = super.parseParenItem(node2, startLoc);
        if (this.eat(17)) {
          node2.optional = true;
          this.resetEndLocation(node2);
        }
        if (this.match(14)) {
          const typeCastNode = this.startNodeAt(startLoc);
          typeCastNode.expression = node2;
          typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
          return this.finishNode(typeCastNode, "TypeCastExpression");
        }
        return node2;
      }
      assertModuleNodeAllowed(node2) {
        if (node2.type === "ImportDeclaration" && (node2.importKind === "type" || node2.importKind === "typeof") || node2.type === "ExportNamedDeclaration" && node2.exportKind === "type" || node2.type === "ExportAllDeclaration" && node2.exportKind === "type") {
          return;
        }
        super.assertModuleNodeAllowed(node2);
      }
      parseExport(node2, decorators) {
        const decl = super.parseExport(node2, decorators);
        if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") {
          decl.exportKind = decl.exportKind || "value";
        }
        return decl;
      }
      parseExportDeclaration(node2) {
        if (this.isContextual(128)) {
          node2.exportKind = "type";
          const declarationNode = this.startNode();
          this.next();
          if (this.match(5)) {
            node2.specifiers = this.parseExportSpecifiers(true);
            super.parseExportFrom(node2);
            return null;
          } else {
            return this.flowParseTypeAlias(declarationNode);
          }
        } else if (this.isContextual(129)) {
          node2.exportKind = "type";
          const declarationNode = this.startNode();
          this.next();
          return this.flowParseOpaqueType(declarationNode, false);
        } else if (this.isContextual(127)) {
          node2.exportKind = "type";
          const declarationNode = this.startNode();
          this.next();
          return this.flowParseInterface(declarationNode);
        } else if (this.shouldParseEnums() && this.isContextual(124)) {
          node2.exportKind = "value";
          const declarationNode = this.startNode();
          this.next();
          return this.flowParseEnumDeclaration(declarationNode);
        } else {
          return super.parseExportDeclaration(node2);
        }
      }
      eatExportStar(node2) {
        if (super.eatExportStar(node2))
          return true;
        if (this.isContextual(128) && this.lookahead().type === 55) {
          node2.exportKind = "type";
          this.next();
          this.next();
          return true;
        }
        return false;
      }
      maybeParseExportNamespaceSpecifier(node2) {
        const {
          startLoc
        } = this.state;
        const hasNamespace = super.maybeParseExportNamespaceSpecifier(node2);
        if (hasNamespace && node2.exportKind === "type") {
          this.unexpected(startLoc);
        }
        return hasNamespace;
      }
      parseClassId(node2, isStatement, optionalId) {
        super.parseClassId(node2, isStatement, optionalId);
        if (this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterDeclaration();
        }
      }
      parseClassMember(classBody, member, state) {
        const {
          startLoc
        } = this.state;
        if (this.isContextual(123)) {
          if (super.parseClassMemberFromModifier(classBody, member)) {
            return;
          }
          member.declare = true;
        }
        super.parseClassMember(classBody, member, state);
        if (member.declare) {
          if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
            this.raise(FlowErrors.DeclareClassElement, {
              at: startLoc
            });
          } else if (member.value) {
            this.raise(FlowErrors.DeclareClassFieldInitializer, {
              at: member.value
            });
          }
        }
      }
      isIterator(word) {
        return word === "iterator" || word === "asyncIterator";
      }
      readIterator() {
        const word = super.readWord1();
        const fullWord = "@@" + word;
        if (!this.isIterator(word) || !this.state.inType) {
          this.raise(Errors.InvalidIdentifier, {
            at: this.state.curPosition(),
            identifierName: fullWord
          });
        }
        this.finishToken(130, fullWord);
      }
      getTokenFromCode(code2) {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (code2 === 123 && next === 124) {
          this.finishOp(6, 2);
        } else if (this.state.inType && (code2 === 62 || code2 === 60)) {
          this.finishOp(code2 === 62 ? 48 : 47, 1);
        } else if (this.state.inType && code2 === 63) {
          if (next === 46) {
            this.finishOp(18, 2);
          } else {
            this.finishOp(17, 1);
          }
        } else if (isIteratorStart(code2, next, this.input.charCodeAt(this.state.pos + 2))) {
          this.state.pos += 2;
          this.readIterator();
        } else {
          super.getTokenFromCode(code2);
        }
      }
      isAssignable(node2, isBinding) {
        if (node2.type === "TypeCastExpression") {
          return this.isAssignable(node2.expression, isBinding);
        } else {
          return super.isAssignable(node2, isBinding);
        }
      }
      toAssignable(node2, isLHS = false) {
        if (!isLHS && node2.type === "AssignmentExpression" && node2.left.type === "TypeCastExpression") {
          node2.left = this.typeCastToParameter(node2.left);
        }
        super.toAssignable(node2, isLHS);
      }
      toAssignableList(exprList, trailingCommaLoc, isLHS) {
        for (let i = 0; i < exprList.length; i++) {
          const expr = exprList[i];
          if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") {
            exprList[i] = this.typeCastToParameter(expr);
          }
        }
        super.toAssignableList(exprList, trailingCommaLoc, isLHS);
      }
      toReferencedList(exprList, isParenthesizedExpr) {
        for (let i = 0; i < exprList.length; i++) {
          var _expr$extra;
          const expr = exprList[i];
          if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
            this.raise(FlowErrors.TypeCastInPattern, {
              at: expr.typeAnnotation
            });
          }
        }
        return exprList;
      }
      parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
        const node2 = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
        if (canBePattern && !this.state.maybeInArrowParameters) {
          this.toReferencedList(node2.elements);
        }
        return node2;
      }
      isValidLVal(type, isParenthesized, binding) {
        return type === "TypeCastExpression" || super.isValidLVal(type, isParenthesized, binding);
      }
      parseClassProperty(node2) {
        if (this.match(14)) {
          node2.typeAnnotation = this.flowParseTypeAnnotation();
        }
        return super.parseClassProperty(node2);
      }
      parseClassPrivateProperty(node2) {
        if (this.match(14)) {
          node2.typeAnnotation = this.flowParseTypeAnnotation();
        }
        return super.parseClassPrivateProperty(node2);
      }
      isClassMethod() {
        return this.match(47) || super.isClassMethod();
      }
      isClassProperty() {
        return this.match(14) || super.isClassProperty();
      }
      isNonstaticConstructor(method) {
        return !this.match(14) && super.isNonstaticConstructor(method);
      }
      pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
        if (method.variance) {
          this.unexpected(method.variance.loc.start);
        }
        delete method.variance;
        if (this.match(47)) {
          method.typeParameters = this.flowParseTypeParameterDeclaration();
        }
        super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
        if (method.params && isConstructor) {
          const params = method.params;
          if (params.length > 0 && this.isThisParam(params[0])) {
            this.raise(FlowErrors.ThisParamBannedInConstructor, {
              at: method
            });
          }
        } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
          const params = method.value.params;
          if (params.length > 0 && this.isThisParam(params[0])) {
            this.raise(FlowErrors.ThisParamBannedInConstructor, {
              at: method
            });
          }
        }
      }
      pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
        if (method.variance) {
          this.unexpected(method.variance.loc.start);
        }
        delete method.variance;
        if (this.match(47)) {
          method.typeParameters = this.flowParseTypeParameterDeclaration();
        }
        super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
      }
      parseClassSuper(node2) {
        super.parseClassSuper(node2);
        if (node2.superClass && this.match(47)) {
          node2.superTypeParameters = this.flowParseTypeParameterInstantiation();
        }
        if (this.isContextual(111)) {
          this.next();
          const implemented = node2.implements = [];
          do {
            const node3 = this.startNode();
            node3.id = this.flowParseRestrictedIdentifier(true);
            if (this.match(47)) {
              node3.typeParameters = this.flowParseTypeParameterInstantiation();
            } else {
              node3.typeParameters = null;
            }
            implemented.push(this.finishNode(node3, "ClassImplements"));
          } while (this.eat(12));
        }
      }
      checkGetterSetterParams(method) {
        super.checkGetterSetterParams(method);
        const params = this.getObjectOrClassMethodParams(method);
        if (params.length > 0) {
          const param = params[0];
          if (this.isThisParam(param) && method.kind === "get") {
            this.raise(FlowErrors.GetterMayNotHaveThisParam, {
              at: param
            });
          } else if (this.isThisParam(param)) {
            this.raise(FlowErrors.SetterMayNotHaveThisParam, {
              at: param
            });
          }
        }
      }
      parsePropertyNamePrefixOperator(node2) {
        node2.variance = this.flowParseVariance();
      }
      parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
        if (prop.variance) {
          this.unexpected(prop.variance.loc.start);
        }
        delete prop.variance;
        let typeParameters;
        if (this.match(47) && !isAccessor) {
          typeParameters = this.flowParseTypeParameterDeclaration();
          if (!this.match(10))
            this.unexpected();
        }
        const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
        if (typeParameters) {
          (result.value || result).typeParameters = typeParameters;
        }
        return result;
      }
      parseAssignableListItemTypes(param) {
        if (this.eat(17)) {
          if (param.type !== "Identifier") {
            this.raise(FlowErrors.PatternIsOptional, {
              at: param
            });
          }
          if (this.isThisParam(param)) {
            this.raise(FlowErrors.ThisParamMayNotBeOptional, {
              at: param
            });
          }
          param.optional = true;
        }
        if (this.match(14)) {
          param.typeAnnotation = this.flowParseTypeAnnotation();
        } else if (this.isThisParam(param)) {
          this.raise(FlowErrors.ThisParamAnnotationRequired, {
            at: param
          });
        }
        if (this.match(29) && this.isThisParam(param)) {
          this.raise(FlowErrors.ThisParamNoDefault, {
            at: param
          });
        }
        this.resetEndLocation(param);
        return param;
      }
      parseMaybeDefault(startLoc, left) {
        const node2 = super.parseMaybeDefault(startLoc, left);
        if (node2.type === "AssignmentPattern" && node2.typeAnnotation && node2.right.start < node2.typeAnnotation.start) {
          this.raise(FlowErrors.TypeBeforeInitializer, {
            at: node2.typeAnnotation
          });
        }
        return node2;
      }
      shouldParseDefaultImport(node2) {
        if (!hasTypeImportKind(node2)) {
          return super.shouldParseDefaultImport(node2);
        }
        return isMaybeDefaultImport(this.state.type);
      }
      checkImportReflection(node2) {
        super.checkImportReflection(node2);
        if (node2.module && node2.importKind !== "value") {
          this.raise(FlowErrors.ImportReflectionHasImportType, {
            at: node2.specifiers[0].loc.start
          });
        }
      }
      parseImportSpecifierLocal(node2, specifier, type) {
        specifier.local = hasTypeImportKind(node2) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
        node2.specifiers.push(this.finishImportSpecifier(specifier, type));
      }
      maybeParseDefaultImportSpecifier(node2) {
        node2.importKind = "value";
        let kind = null;
        if (this.match(87)) {
          kind = "typeof";
        } else if (this.isContextual(128)) {
          kind = "type";
        }
        if (kind) {
          const lh = this.lookahead();
          const {
            type
          } = lh;
          if (kind === "type" && type === 55) {
            this.unexpected(null, lh.type);
          }
          if (isMaybeDefaultImport(type) || type === 5 || type === 55) {
            this.next();
            node2.importKind = kind;
          }
        }
        return super.maybeParseDefaultImportSpecifier(node2);
      }
      parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
        const firstIdent = specifier.imported;
        let specifierTypeKind = null;
        if (firstIdent.type === "Identifier") {
          if (firstIdent.name === "type") {
            specifierTypeKind = "type";
          } else if (firstIdent.name === "typeof") {
            specifierTypeKind = "typeof";
          }
        }
        let isBinding = false;
        if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
          const as_ident = this.parseIdentifier(true);
          if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
            specifier.imported = as_ident;
            specifier.importKind = specifierTypeKind;
            specifier.local = cloneIdentifier(as_ident);
          } else {
            specifier.imported = firstIdent;
            specifier.importKind = null;
            specifier.local = this.parseIdentifier();
          }
        } else {
          if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
            specifier.imported = this.parseIdentifier(true);
            specifier.importKind = specifierTypeKind;
          } else {
            if (importedIsString) {
              throw this.raise(Errors.ImportBindingIsString, {
                at: specifier,
                importName: firstIdent.value
              });
            }
            specifier.imported = firstIdent;
            specifier.importKind = null;
          }
          if (this.eatContextual(93)) {
            specifier.local = this.parseIdentifier();
          } else {
            isBinding = true;
            specifier.local = cloneIdentifier(specifier.imported);
          }
        }
        const specifierIsTypeImport = hasTypeImportKind(specifier);
        if (isInTypeOnlyImport && specifierIsTypeImport) {
          this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
            at: specifier
          });
        }
        if (isInTypeOnlyImport || specifierIsTypeImport) {
          this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
        }
        if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {
          this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
        }
        return this.finishImportSpecifier(specifier, "ImportSpecifier");
      }
      parseBindingAtom() {
        switch (this.state.type) {
          case 78:
            return this.parseIdentifier(true);
          default:
            return super.parseBindingAtom();
        }
      }
      parseFunctionParams(node2, isConstructor) {
        const kind = node2.kind;
        if (kind !== "get" && kind !== "set" && this.match(47)) {
          node2.typeParameters = this.flowParseTypeParameterDeclaration();
        }
        super.parseFunctionParams(node2, isConstructor);
      }
      parseVarId(decl, kind) {
        super.parseVarId(decl, kind);
        if (this.match(14)) {
          decl.id.typeAnnotation = this.flowParseTypeAnnotation();
          this.resetEndLocation(decl.id);
        }
      }
      parseAsyncArrowFromCallExpression(node2, call) {
        if (this.match(14)) {
          const oldNoAnonFunctionType = this.state.noAnonFunctionType;
          this.state.noAnonFunctionType = true;
          node2.returnType = this.flowParseTypeAnnotation();
          this.state.noAnonFunctionType = oldNoAnonFunctionType;
        }
        return super.parseAsyncArrowFromCallExpression(node2, call);
      }
      shouldParseAsyncArrow() {
        return this.match(14) || super.shouldParseAsyncArrow();
      }
      parseMaybeAssign(refExpressionErrors, afterLeftParse) {
        var _jsx;
        let state = null;
        let jsx3;
        if (this.hasPlugin("jsx") && (this.match(140) || this.match(47))) {
          state = this.state.clone();
          jsx3 = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
          if (!jsx3.error)
            return jsx3.node;
          const {
            context
          } = this.state;
          const currentContext = context[context.length - 1];
          if (currentContext === types3.j_oTag || currentContext === types3.j_expr) {
            context.pop();
          }
        }
        if ((_jsx = jsx3) != null && _jsx.error || this.match(47)) {
          var _jsx2, _jsx3;
          state = state || this.state.clone();
          let typeParameters;
          const arrow = this.tryParse((abort) => {
            var _arrowExpression$extr;
            typeParameters = this.flowParseTypeParameterDeclaration();
            const arrowExpression2 = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
              const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
              this.resetStartLocationFromNode(result, typeParameters);
              return result;
            });
            if ((_arrowExpression$extr = arrowExpression2.extra) != null && _arrowExpression$extr.parenthesized)
              abort();
            const expr = this.maybeUnwrapTypeCastExpression(arrowExpression2);
            if (expr.type !== "ArrowFunctionExpression")
              abort();
            expr.typeParameters = typeParameters;
            this.resetStartLocationFromNode(expr, typeParameters);
            return arrowExpression2;
          }, state);
          let arrowExpression = null;
          if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
            if (!arrow.error && !arrow.aborted) {
              if (arrow.node.async) {
                this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, {
                  at: typeParameters
                });
              }
              return arrow.node;
            }
            arrowExpression = arrow.node;
          }
          if ((_jsx2 = jsx3) != null && _jsx2.node) {
            this.state = jsx3.failState;
            return jsx3.node;
          }
          if (arrowExpression) {
            this.state = arrow.failState;
            return arrowExpression;
          }
          if ((_jsx3 = jsx3) != null && _jsx3.thrown)
            throw jsx3.error;
          if (arrow.thrown)
            throw arrow.error;
          throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {
            at: typeParameters
          });
        }
        return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
      }
      parseArrow(node2) {
        if (this.match(14)) {
          const result = this.tryParse(() => {
            const oldNoAnonFunctionType = this.state.noAnonFunctionType;
            this.state.noAnonFunctionType = true;
            const typeNode = this.startNode();
            [typeNode.typeAnnotation, node2.predicate] = this.flowParseTypeAndPredicateInitialiser();
            this.state.noAnonFunctionType = oldNoAnonFunctionType;
            if (this.canInsertSemicolon())
              this.unexpected();
            if (!this.match(19))
              this.unexpected();
            return typeNode;
          });
          if (result.thrown)
            return null;
          if (result.error)
            this.state = result.failState;
          node2.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
        }
        return super.parseArrow(node2);
      }
      shouldParseArrow(params) {
        return this.match(14) || super.shouldParseArrow(params);
      }
      setArrowFunctionParameters(node2, params) {
        if (this.state.noArrowParamsConversionAt.indexOf(node2.start) !== -1) {
          node2.params = params;
        } else {
          super.setArrowFunctionParameters(node2, params);
        }
      }
      checkParams(node2, allowDuplicates, isArrowFunction, strictModeChanged = true) {
        if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node2.start) !== -1) {
          return;
        }
        for (let i = 0; i < node2.params.length; i++) {
          if (this.isThisParam(node2.params[i]) && i > 0) {
            this.raise(FlowErrors.ThisParamMustBeFirst, {
              at: node2.params[i]
            });
          }
        }
        super.checkParams(node2, allowDuplicates, isArrowFunction, strictModeChanged);
      }
      parseParenAndDistinguishExpression(canBeArrow) {
        return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
      }
      parseSubscripts(base2, startLoc, noCalls) {
        if (base2.type === "Identifier" && base2.name === "async" && this.state.noArrowAt.indexOf(startLoc.index) !== -1) {
          this.next();
          const node2 = this.startNodeAt(startLoc);
          node2.callee = base2;
          node2.arguments = super.parseCallExpressionArguments(11, false);
          base2 = this.finishNode(node2, "CallExpression");
        } else if (base2.type === "Identifier" && base2.name === "async" && this.match(47)) {
          const state = this.state.clone();
          const arrow = this.tryParse((abort) => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);
          if (!arrow.error && !arrow.aborted)
            return arrow.node;
          const result = this.tryParse(() => super.parseSubscripts(base2, startLoc, noCalls), state);
          if (result.node && !result.error)
            return result.node;
          if (arrow.node) {
            this.state = arrow.failState;
            return arrow.node;
          }
          if (result.node) {
            this.state = result.failState;
            return result.node;
          }
          throw arrow.error || result.error;
        }
        return super.parseSubscripts(base2, startLoc, noCalls);
      }
      parseSubscript(base2, startLoc, noCalls, subscriptState) {
        if (this.match(18) && this.isLookaheadToken_lt()) {
          subscriptState.optionalChainMember = true;
          if (noCalls) {
            subscriptState.stop = true;
            return base2;
          }
          this.next();
          const node2 = this.startNodeAt(startLoc);
          node2.callee = base2;
          node2.typeArguments = this.flowParseTypeParameterInstantiation();
          this.expect(10);
          node2.arguments = this.parseCallExpressionArguments(11, false);
          node2.optional = true;
          return this.finishCallExpression(node2, true);
        } else if (!noCalls && this.shouldParseTypes() && this.match(47)) {
          const node2 = this.startNodeAt(startLoc);
          node2.callee = base2;
          const result = this.tryParse(() => {
            node2.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
            this.expect(10);
            node2.arguments = super.parseCallExpressionArguments(11, false);
            if (subscriptState.optionalChainMember) {
              node2.optional = false;
            }
            return this.finishCallExpression(node2, subscriptState.optionalChainMember);
          });
          if (result.node) {
            if (result.error)
              this.state = result.failState;
            return result.node;
          }
        }
        return super.parseSubscript(base2, startLoc, noCalls, subscriptState);
      }
      parseNewCallee(node2) {
        super.parseNewCallee(node2);
        let targs = null;
        if (this.shouldParseTypes() && this.match(47)) {
          targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
        }
        node2.typeArguments = targs;
      }
      parseAsyncArrowWithTypeParameters(startLoc) {
        const node2 = this.startNodeAt(startLoc);
        this.parseFunctionParams(node2, false);
        if (!this.parseArrow(node2))
          return;
        return super.parseArrowExpression(node2, void 0, true);
      }
      readToken_mult_modulo(code2) {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (code2 === 42 && next === 47 && this.state.hasFlowComment) {
          this.state.hasFlowComment = false;
          this.state.pos += 2;
          this.nextToken();
          return;
        }
        super.readToken_mult_modulo(code2);
      }
      readToken_pipe_amp(code2) {
        const next = this.input.charCodeAt(this.state.pos + 1);
        if (code2 === 124 && next === 125) {
          this.finishOp(9, 2);
          return;
        }
        super.readToken_pipe_amp(code2);
      }
      parseTopLevel(file, program) {
        const fileNode = super.parseTopLevel(file, program);
        if (this.state.hasFlowComment) {
          this.raise(FlowErrors.UnterminatedFlowComment, {
            at: this.state.curPosition()
          });
        }
        return fileNode;
      }
      skipBlockComment() {
        if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
          if (this.state.hasFlowComment) {
            throw this.raise(FlowErrors.NestedFlowComment, {
              at: this.state.startLoc
            });
          }
          this.hasFlowCommentCompletion();
          const commentSkip = this.skipFlowComment();
          if (commentSkip) {
            this.state.pos += commentSkip;
            this.state.hasFlowComment = true;
          }
          return;
        }
        return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
      }
      skipFlowComment() {
        const {
          pos: pos2
        } = this.state;
        let shiftToFirstNonWhiteSpace = 2;
        while ([32, 9].includes(this.input.charCodeAt(pos2 + shiftToFirstNonWhiteSpace))) {
          shiftToFirstNonWhiteSpace++;
        }
        const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos2);
        const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos2 + 1);
        if (ch2 === 58 && ch3 === 58) {
          return shiftToFirstNonWhiteSpace + 2;
        }
        if (this.input.slice(shiftToFirstNonWhiteSpace + pos2, shiftToFirstNonWhiteSpace + pos2 + 12) === "flow-include") {
          return shiftToFirstNonWhiteSpace + 12;
        }
        if (ch2 === 58 && ch3 !== 58) {
          return shiftToFirstNonWhiteSpace;
        }
        return false;
      }
      hasFlowCommentCompletion() {
        const end = this.input.indexOf("*/", this.state.pos);
        if (end === -1) {
          throw this.raise(Errors.UnterminatedComment, {
            at: this.state.curPosition()
          });
        }
      }
      flowEnumErrorBooleanMemberNotInitialized(loc, {
        enumName,
        memberName
      }) {
        this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
          at: loc,
          memberName,
          enumName
        });
      }
      flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
        return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({
          at: loc
        }, enumContext));
      }
      flowEnumErrorNumberMemberNotInitialized(loc, {
        enumName,
        memberName
      }) {
        this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
          at: loc,
          enumName,
          memberName
        });
      }
      flowEnumErrorStringMemberInconsistentlyInitailized(node2, {
        enumName
      }) {
        this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {
          at: node2,
          enumName
        });
      }
      flowEnumMemberInit() {
        const startLoc = this.state.startLoc;
        const endOfInit = () => this.match(12) || this.match(8);
        switch (this.state.type) {
          case 132: {
            const literal4 = this.parseNumericLiteral(this.state.value);
            if (endOfInit()) {
              return {
                type: "number",
                loc: literal4.loc.start,
                value: literal4
              };
            }
            return {
              type: "invalid",
              loc: startLoc
            };
          }
          case 131: {
            const literal4 = this.parseStringLiteral(this.state.value);
            if (endOfInit()) {
              return {
                type: "string",
                loc: literal4.loc.start,
                value: literal4
              };
            }
            return {
              type: "invalid",
              loc: startLoc
            };
          }
          case 85:
          case 86: {
            const literal4 = this.parseBooleanLiteral(this.match(85));
            if (endOfInit()) {
              return {
                type: "boolean",
                loc: literal4.loc.start,
                value: literal4
              };
            }
            return {
              type: "invalid",
              loc: startLoc
            };
          }
          default:
            return {
              type: "invalid",
              loc: startLoc
            };
        }
      }
      flowEnumMemberRaw() {
        const loc = this.state.startLoc;
        const id = this.parseIdentifier(true);
        const init = this.eat(29) ? this.flowEnumMemberInit() : {
          type: "none",
          loc
        };
        return {
          id,
          init
        };
      }
      flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
        const {
          explicitType
        } = context;
        if (explicitType === null) {
          return;
        }
        if (explicitType !== expectedType) {
          this.flowEnumErrorInvalidMemberInitializer(loc, context);
        }
      }
      flowEnumMembers({
        enumName,
        explicitType
      }) {
        const seenNames = /* @__PURE__ */ new Set();
        const members = {
          booleanMembers: [],
          numberMembers: [],
          stringMembers: [],
          defaultedMembers: []
        };
        let hasUnknownMembers = false;
        while (!this.match(8)) {
          if (this.eat(21)) {
            hasUnknownMembers = true;
            break;
          }
          const memberNode = this.startNode();
          const {
            id,
            init
          } = this.flowEnumMemberRaw();
          const memberName = id.name;
          if (memberName === "") {
            continue;
          }
          if (/^[a-z]/.test(memberName)) {
            this.raise(FlowErrors.EnumInvalidMemberName, {
              at: id,
              memberName,
              suggestion: memberName[0].toUpperCase() + memberName.slice(1),
              enumName
            });
          }
          if (seenNames.has(memberName)) {
            this.raise(FlowErrors.EnumDuplicateMemberName, {
              at: id,
              memberName,
              enumName
            });
          }
          seenNames.add(memberName);
          const context = {
            enumName,
            explicitType,
            memberName
          };
          memberNode.id = id;
          switch (init.type) {
            case "boolean": {
              this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
              memberNode.init = init.value;
              members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
              break;
            }
            case "number": {
              this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
              memberNode.init = init.value;
              members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
              break;
            }
            case "string": {
              this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
              memberNode.init = init.value;
              members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
              break;
            }
            case "invalid": {
              throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
            }
            case "none": {
              switch (explicitType) {
                case "boolean":
                  this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
                  break;
                case "number":
                  this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
                  break;
                default:
                  members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
              }
            }
          }
          if (!this.match(8)) {
            this.expect(12);
          }
        }
        return {
          members,
          hasUnknownMembers
        };
      }
      flowEnumStringMembers(initializedMembers, defaultedMembers, {
        enumName
      }) {
        if (initializedMembers.length === 0) {
          return defaultedMembers;
        } else if (defaultedMembers.length === 0) {
          return initializedMembers;
        } else if (defaultedMembers.length > initializedMembers.length) {
          for (const member of initializedMembers) {
            this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
              enumName
            });
          }
          return defaultedMembers;
        } else {
          for (const member of defaultedMembers) {
            this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
              enumName
            });
          }
          return initializedMembers;
        }
      }
      flowEnumParseExplicitType({
        enumName
      }) {
        if (!this.eatContextual(101))
          return null;
        if (!tokenIsIdentifier(this.state.type)) {
          throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {
            at: this.state.startLoc,
            enumName
          });
        }
        const {
          value: value2
        } = this.state;
        this.next();
        if (value2 !== "boolean" && value2 !== "number" && value2 !== "string" && value2 !== "symbol") {
          this.raise(FlowErrors.EnumInvalidExplicitType, {
            at: this.state.startLoc,
            enumName,
            invalidEnumType: value2
          });
        }
        return value2;
      }
      flowEnumBody(node2, id) {
        const enumName = id.name;
        const nameLoc = id.loc.start;
        const explicitType = this.flowEnumParseExplicitType({
          enumName
        });
        this.expect(5);
        const {
          members,
          hasUnknownMembers
        } = this.flowEnumMembers({
          enumName,
          explicitType
        });
        node2.hasUnknownMembers = hasUnknownMembers;
        switch (explicitType) {
          case "boolean":
            node2.explicitType = true;
            node2.members = members.booleanMembers;
            this.expect(8);
            return this.finishNode(node2, "EnumBooleanBody");
          case "number":
            node2.explicitType = true;
            node2.members = members.numberMembers;
            this.expect(8);
            return this.finishNode(node2, "EnumNumberBody");
          case "string":
            node2.explicitType = true;
            node2.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
              enumName
            });
            this.expect(8);
            return this.finishNode(node2, "EnumStringBody");
          case "symbol":
            node2.members = members.defaultedMembers;
            this.expect(8);
            return this.finishNode(node2, "EnumSymbolBody");
          default: {
            const empty4 = () => {
              node2.members = [];
              this.expect(8);
              return this.finishNode(node2, "EnumStringBody");
            };
            node2.explicitType = false;
            const boolsLen = members.booleanMembers.length;
            const numsLen = members.numberMembers.length;
            const strsLen = members.stringMembers.length;
            const defaultedLen = members.defaultedMembers.length;
            if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
              return empty4();
            } else if (!boolsLen && !numsLen) {
              node2.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
                enumName
              });
              this.expect(8);
              return this.finishNode(node2, "EnumStringBody");
            } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
              for (const member of members.defaultedMembers) {
                this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
                  enumName,
                  memberName: member.id.name
                });
              }
              node2.members = members.booleanMembers;
              this.expect(8);
              return this.finishNode(node2, "EnumBooleanBody");
            } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
              for (const member of members.defaultedMembers) {
                this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
                  enumName,
                  memberName: member.id.name
                });
              }
              node2.members = members.numberMembers;
              this.expect(8);
              return this.finishNode(node2, "EnumNumberBody");
            } else {
              this.raise(FlowErrors.EnumInconsistentMemberValues, {
                at: nameLoc,
                enumName
              });
              return empty4();
            }
          }
        }
      }
      flowParseEnumDeclaration(node2) {
        const id = this.parseIdentifier();
        node2.id = id;
        node2.body = this.flowEnumBody(this.startNode(), id);
        return this.finishNode(node2, "EnumDeclaration");
      }
      isLookaheadToken_lt() {
        const next = this.nextTokenStart();
        if (this.input.charCodeAt(next) === 60) {
          const afterNext = this.input.charCodeAt(next + 1);
          return afterNext !== 60 && afterNext !== 61;
        }
        return false;
      }
      maybeUnwrapTypeCastExpression(node2) {
        return node2.type === "TypeCastExpression" ? node2.expression : node2;
      }
    };
    var entities = {
      __proto__: null,
      quot: '"',
      amp: "&",
      apos: "'",
      lt: "<",
      gt: ">",
      nbsp: "\xA0",
      iexcl: "\xA1",
      cent: "\xA2",
      pound: "\xA3",
      curren: "\xA4",
      yen: "\xA5",
      brvbar: "\xA6",
      sect: "\xA7",
      uml: "\xA8",
      copy: "\xA9",
      ordf: "\xAA",
      laquo: "\xAB",
      not: "\xAC",
      shy: "\xAD",
      reg: "\xAE",
      macr: "\xAF",
      deg: "\xB0",
      plusmn: "\xB1",
      sup2: "\xB2",
      sup3: "\xB3",
      acute: "\xB4",
      micro: "\xB5",
      para: "\xB6",
      middot: "\xB7",
      cedil: "\xB8",
      sup1: "\xB9",
      ordm: "\xBA",
      raquo: "\xBB",
      frac14: "\xBC",
      frac12: "\xBD",
      frac34: "\xBE",
      iquest: "\xBF",
      Agrave: "\xC0",
      Aacute: "\xC1",
      Acirc: "\xC2",
      Atilde: "\xC3",
      Auml: "\xC4",
      Aring: "\xC5",
      AElig: "\xC6",
      Ccedil: "\xC7",
      Egrave: "\xC8",
      Eacute: "\xC9",
      Ecirc: "\xCA",
      Euml: "\xCB",
      Igrave: "\xCC",
      Iacute: "\xCD",
      Icirc: "\xCE",
      Iuml: "\xCF",
      ETH: "\xD0",
      Ntilde: "\xD1",
      Ograve: "\xD2",
      Oacute: "\xD3",
      Ocirc: "\xD4",
      Otilde: "\xD5",
      Ouml: "\xD6",
      times: "\xD7",
      Oslash: "\xD8",
      Ugrave: "\xD9",
      Uacute: "\xDA",
      Ucirc: "\xDB",
      Uuml: "\xDC",
      Yacute: "\xDD",
      THORN: "\xDE",
      szlig: "\xDF",
      agrave: "\xE0",
      aacute: "\xE1",
      acirc: "\xE2",
      atilde: "\xE3",
      auml: "\xE4",
      aring: "\xE5",
      aelig: "\xE6",
      ccedil: "\xE7",
      egrave: "\xE8",
      eacute: "\xE9",
      ecirc: "\xEA",
      euml: "\xEB",
      igrave: "\xEC",
      iacute: "\xED",
      icirc: "\xEE",
      iuml: "\xEF",
      eth: "\xF0",
      ntilde: "\xF1",
      ograve: "\xF2",
      oacute: "\xF3",
      ocirc: "\xF4",
      otilde: "\xF5",
      ouml: "\xF6",
      divide: "\xF7",
      oslash: "\xF8",
      ugrave: "\xF9",
      uacute: "\xFA",
      ucirc: "\xFB",
      uuml: "\xFC",
      yacute: "\xFD",
      thorn: "\xFE",
      yuml: "\xFF",
      OElig: "\u0152",
      oelig: "\u0153",
      Scaron: "\u0160",
      scaron: "\u0161",
      Yuml: "\u0178",
      fnof: "\u0192",
      circ: "\u02C6",
      tilde: "\u02DC",
      Alpha: "\u0391",
      Beta: "\u0392",
      Gamma: "\u0393",
      Delta: "\u0394",
      Epsilon: "\u0395",
      Zeta: "\u0396",
      Eta: "\u0397",
      Theta: "\u0398",
      Iota: "\u0399",
      Kappa: "\u039A",
      Lambda: "\u039B",
      Mu: "\u039C",
      Nu: "\u039D",
      Xi: "\u039E",
      Omicron: "\u039F",
      Pi: "\u03A0",
      Rho: "\u03A1",
      Sigma: "\u03A3",
      Tau: "\u03A4",
      Upsilon: "\u03A5",
      Phi: "\u03A6",
      Chi: "\u03A7",
      Psi: "\u03A8",
      Omega: "\u03A9",
      alpha: "\u03B1",
      beta: "\u03B2",
      gamma: "\u03B3",
      delta: "\u03B4",
      epsilon: "\u03B5",
      zeta: "\u03B6",
      eta: "\u03B7",
      theta: "\u03B8",
      iota: "\u03B9",
      kappa: "\u03BA",
      lambda: "\u03BB",
      mu: "\u03BC",
      nu: "\u03BD",
      xi: "\u03BE",
      omicron: "\u03BF",
      pi: "\u03C0",
      rho: "\u03C1",
      sigmaf: "\u03C2",
      sigma: "\u03C3",
      tau: "\u03C4",
      upsilon: "\u03C5",
      phi: "\u03C6",
      chi: "\u03C7",
      psi: "\u03C8",
      omega: "\u03C9",
      thetasym: "\u03D1",
      upsih: "\u03D2",
      piv: "\u03D6",
      ensp: "\u2002",
      emsp: "\u2003",
      thinsp: "\u2009",
      zwnj: "\u200C",
      zwj: "\u200D",
      lrm: "\u200E",
      rlm: "\u200F",
      ndash: "\u2013",
      mdash: "\u2014",
      lsquo: "\u2018",
      rsquo: "\u2019",
      sbquo: "\u201A",
      ldquo: "\u201C",
      rdquo: "\u201D",
      bdquo: "\u201E",
      dagger: "\u2020",
      Dagger: "\u2021",
      bull: "\u2022",
      hellip: "\u2026",
      permil: "\u2030",
      prime: "\u2032",
      Prime: "\u2033",
      lsaquo: "\u2039",
      rsaquo: "\u203A",
      oline: "\u203E",
      frasl: "\u2044",
      euro: "\u20AC",
      image: "\u2111",
      weierp: "\u2118",
      real: "\u211C",
      trade: "\u2122",
      alefsym: "\u2135",
      larr: "\u2190",
      uarr: "\u2191",
      rarr: "\u2192",
      darr: "\u2193",
      harr: "\u2194",
      crarr: "\u21B5",
      lArr: "\u21D0",
      uArr: "\u21D1",
      rArr: "\u21D2",
      dArr: "\u21D3",
      hArr: "\u21D4",
      forall: "\u2200",
      part: "\u2202",
      exist: "\u2203",
      empty: "\u2205",
      nabla: "\u2207",
      isin: "\u2208",
      notin: "\u2209",
      ni: "\u220B",
      prod: "\u220F",
      sum: "\u2211",
      minus: "\u2212",
      lowast: "\u2217",
      radic: "\u221A",
      prop: "\u221D",
      infin: "\u221E",
      ang: "\u2220",
      and: "\u2227",
      or: "\u2228",
      cap: "\u2229",
      cup: "\u222A",
      int: "\u222B",
      there4: "\u2234",
      sim: "\u223C",
      cong: "\u2245",
      asymp: "\u2248",
      ne: "\u2260",
      equiv: "\u2261",
      le: "\u2264",
      ge: "\u2265",
      sub: "\u2282",
      sup: "\u2283",
      nsub: "\u2284",
      sube: "\u2286",
      supe: "\u2287",
      oplus: "\u2295",
      otimes: "\u2297",
      perp: "\u22A5",
      sdot: "\u22C5",
      lceil: "\u2308",
      rceil: "\u2309",
      lfloor: "\u230A",
      rfloor: "\u230B",
      lang: "\u2329",
      rang: "\u232A",
      loz: "\u25CA",
      spades: "\u2660",
      clubs: "\u2663",
      hearts: "\u2665",
      diams: "\u2666"
    };
    var JsxErrors = ParseErrorEnum`jsx`({
      AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
      MissingClosingTagElement: ({
        openingTagName
      }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
      MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
      UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
      UnexpectedToken: ({
        unexpected,
        HTMLEntity
      }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
      UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
      UnterminatedJsxContent: "Unterminated JSX contents.",
      UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
    });
    function isFragment(object) {
      return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
    }
    function getQualifiedJSXName(object) {
      if (object.type === "JSXIdentifier") {
        return object.name;
      }
      if (object.type === "JSXNamespacedName") {
        return object.namespace.name + ":" + object.name.name;
      }
      if (object.type === "JSXMemberExpression") {
        return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
      }
      throw new Error("Node had unexpected type: " + object.type);
    }
    var jsx2 = (superClass) => class JSXParserMixin extends superClass {
      jsxReadToken() {
        let out = "";
        let chunkStart = this.state.pos;
        for (; ; ) {
          if (this.state.pos >= this.length) {
            throw this.raise(JsxErrors.UnterminatedJsxContent, {
              at: this.state.startLoc
            });
          }
          const ch = this.input.charCodeAt(this.state.pos);
          switch (ch) {
            case 60:
            case 123:
              if (this.state.pos === this.state.start) {
                if (ch === 60 && this.state.canStartJSXElement) {
                  ++this.state.pos;
                  this.finishToken(140);
                } else {
                  super.getTokenFromCode(ch);
                }
                return;
              }
              out += this.input.slice(chunkStart, this.state.pos);
              this.finishToken(139, out);
              return;
            case 38:
              out += this.input.slice(chunkStart, this.state.pos);
              out += this.jsxReadEntity();
              chunkStart = this.state.pos;
              break;
            case 62:
            case 125:
            default:
              if (isNewLine3(ch)) {
                out += this.input.slice(chunkStart, this.state.pos);
                out += this.jsxReadNewLine(true);
                chunkStart = this.state.pos;
              } else {
                ++this.state.pos;
              }
          }
        }
      }
      jsxReadNewLine(normalizeCRLF) {
        const ch = this.input.charCodeAt(this.state.pos);
        let out;
        ++this.state.pos;
        if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
          ++this.state.pos;
          out = normalizeCRLF ? "\n" : "\r\n";
        } else {
          out = String.fromCharCode(ch);
        }
        ++this.state.curLine;
        this.state.lineStart = this.state.pos;
        return out;
      }
      jsxReadString(quote) {
        let out = "";
        let chunkStart = ++this.state.pos;
        for (; ; ) {
          if (this.state.pos >= this.length) {
            throw this.raise(Errors.UnterminatedString, {
              at: this.state.startLoc
            });
          }
          const ch = this.input.charCodeAt(this.state.pos);
          if (ch === quote)
            break;
          if (ch === 38) {
            out += this.input.slice(chunkStart, this.state.pos);
            out += this.jsxReadEntity();
            chunkStart = this.state.pos;
          } else if (isNewLine3(ch)) {
            out += this.input.slice(chunkStart, this.state.pos);
            out += this.jsxReadNewLine(false);
            chunkStart = this.state.pos;
          } else {
            ++this.state.pos;
          }
        }
        out += this.input.slice(chunkStart, this.state.pos++);
        this.finishToken(131, out);
      }
      jsxReadEntity() {
        const startPos = ++this.state.pos;
        if (this.codePointAtPos(this.state.pos) === 35) {
          ++this.state.pos;
          let radix = 10;
          if (this.codePointAtPos(this.state.pos) === 120) {
            radix = 16;
            ++this.state.pos;
          }
          const codePoint = this.readInt(radix, void 0, false, "bail");
          if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
            ++this.state.pos;
            return String.fromCodePoint(codePoint);
          }
        } else {
          let count = 0;
          let semi = false;
          while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) {
            ++this.state.pos;
          }
          if (semi) {
            const desc = this.input.slice(startPos, this.state.pos);
            const entity = entities[desc];
            ++this.state.pos;
            if (entity) {
              return entity;
            }
          }
        }
        this.state.pos = startPos;
        return "&";
      }
      jsxReadWord() {
        let ch;
        const start3 = this.state.pos;
        do {
          ch = this.input.charCodeAt(++this.state.pos);
        } while (isIdentifierChar3(ch) || ch === 45);
        this.finishToken(138, this.input.slice(start3, this.state.pos));
      }
      jsxParseIdentifier() {
        const node2 = this.startNode();
        if (this.match(138)) {
          node2.name = this.state.value;
        } else if (tokenIsKeyword(this.state.type)) {
          node2.name = tokenLabelName(this.state.type);
        } else {
          this.unexpected();
        }
        this.next();
        return this.finishNode(node2, "JSXIdentifier");
      }
      jsxParseNamespacedName() {
        const startLoc = this.state.startLoc;
        const name2 = this.jsxParseIdentifier();
        if (!this.eat(14))
          return name2;
        const node2 = this.startNodeAt(startLoc);
        node2.namespace = name2;
        node2.name = this.jsxParseIdentifier();
        return this.finishNode(node2, "JSXNamespacedName");
      }
      jsxParseElementName() {
        const startLoc = this.state.startLoc;
        let node2 = this.jsxParseNamespacedName();
        if (node2.type === "JSXNamespacedName") {
          return node2;
        }
        while (this.eat(16)) {
          const newNode = this.startNodeAt(startLoc);
          newNode.object = node2;
          newNode.property = this.jsxParseIdentifier();
          node2 = this.finishNode(newNode, "JSXMemberExpression");
        }
        return node2;
      }
      jsxParseAttributeValue() {
        let node2;
        switch (this.state.type) {
          case 5:
            node2 = this.startNode();
            this.setContext(types3.brace);
            this.next();
            node2 = this.jsxParseExpressionContainer(node2, types3.j_oTag);
            if (node2.expression.type === "JSXEmptyExpression") {
              this.raise(JsxErrors.AttributeIsEmpty, {
                at: node2
              });
            }
            return node2;
          case 140:
          case 131:
            return this.parseExprAtom();
          default:
            throw this.raise(JsxErrors.UnsupportedJsxValue, {
              at: this.state.startLoc
            });
        }
      }
      jsxParseEmptyExpression() {
        const node2 = this.startNodeAt(this.state.lastTokEndLoc);
        return this.finishNodeAt(node2, "JSXEmptyExpression", this.state.startLoc);
      }
      jsxParseSpreadChild(node2) {
        this.next();
        node2.expression = this.parseExpression();
        this.setContext(types3.j_expr);
        this.state.canStartJSXElement = true;
        this.expect(8);
        return this.finishNode(node2, "JSXSpreadChild");
      }
      jsxParseExpressionContainer(node2, previousContext) {
        if (this.match(8)) {
          node2.expression = this.jsxParseEmptyExpression();
        } else {
          const expression = this.parseExpression();
          node2.expression = expression;
        }
        this.setContext(previousContext);
        this.state.canStartJSXElement = true;
        this.expect(8);
        return this.finishNode(node2, "JSXExpressionContainer");
      }
      jsxParseAttribute() {
        const node2 = this.startNode();
        if (this.match(5)) {
          this.setContext(types3.brace);
          this.next();
          this.expect(21);
          node2.argument = this.parseMaybeAssignAllowIn();
          this.setContext(types3.j_oTag);
          this.state.canStartJSXElement = true;
          this.expect(8);
          return this.finishNode(node2, "JSXSpreadAttribute");
        }
        node2.name = this.jsxParseNamespacedName();
        node2.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
        return this.finishNode(node2, "JSXAttribute");
      }
      jsxParseOpeningElementAt(startLoc) {
        const node2 = this.startNodeAt(startLoc);
        if (this.eat(141)) {
          return this.finishNode(node2, "JSXOpeningFragment");
        }
        node2.name = this.jsxParseElementName();
        return this.jsxParseOpeningElementAfterName(node2);
      }
      jsxParseOpeningElementAfterName(node2) {
        const attributes = [];
        while (!this.match(56) && !this.match(141)) {
          attributes.push(this.jsxParseAttribute());
        }
        node2.attributes = attributes;
        node2.selfClosing = this.eat(56);
        this.expect(141);
        return this.finishNode(node2, "JSXOpeningElement");
      }
      jsxParseClosingElementAt(startLoc) {
        const node2 = this.startNodeAt(startLoc);
        if (this.eat(141)) {
          return this.finishNode(node2, "JSXClosingFragment");
        }
        node2.name = this.jsxParseElementName();
        this.expect(141);
        return this.finishNode(node2, "JSXClosingElement");
      }
      jsxParseElementAt(startLoc) {
        const node2 = this.startNodeAt(startLoc);
        const children = [];
        const openingElement = this.jsxParseOpeningElementAt(startLoc);
        let closingElement = null;
        if (!openingElement.selfClosing) {
          contents:
            for (; ; ) {
              switch (this.state.type) {
                case 140:
                  startLoc = this.state.startLoc;
                  this.next();
                  if (this.eat(56)) {
                    closingElement = this.jsxParseClosingElementAt(startLoc);
                    break contents;
                  }
                  children.push(this.jsxParseElementAt(startLoc));
                  break;
                case 139:
                  children.push(this.parseExprAtom());
                  break;
                case 5: {
                  const node3 = this.startNode();
                  this.setContext(types3.brace);
                  this.next();
                  if (this.match(21)) {
                    children.push(this.jsxParseSpreadChild(node3));
                  } else {
                    children.push(this.jsxParseExpressionContainer(node3, types3.j_expr));
                  }
                  break;
                }
                default:
                  this.unexpected();
              }
            }
          if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
            this.raise(JsxErrors.MissingClosingTagFragment, {
              at: closingElement
            });
          } else if (!isFragment(openingElement) && isFragment(closingElement)) {
            this.raise(JsxErrors.MissingClosingTagElement, {
              at: closingElement,
              openingTagName: getQualifiedJSXName(openingElement.name)
            });
          } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
            if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
              this.raise(JsxErrors.MissingClosingTagElement, {
                at: closingElement,
                openingTagName: getQualifiedJSXName(openingElement.name)
              });
            }
          }
        }
        if (isFragment(openingElement)) {
          node2.openingFragment = openingElement;
          node2.closingFragment = closingElement;
        } else {
          node2.openingElement = openingElement;
          node2.closingElement = closingElement;
        }
        node2.children = children;
        if (this.match(47)) {
          throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {
            at: this.state.startLoc
          });
        }
        return isFragment(openingElement) ? this.finishNode(node2, "JSXFragment") : this.finishNode(node2, "JSXElement");
      }
      jsxParseElement() {
        const startLoc = this.state.startLoc;
        this.next();
        return this.jsxParseElementAt(startLoc);
      }
      setContext(newContext) {
        const {
          context
        } = this.state;
        context[context.length - 1] = newContext;
      }
      parseExprAtom(refExpressionErrors) {
        if (this.match(139)) {
          return this.parseLiteral(this.state.value, "JSXText");
        } else if (this.match(140)) {
          return this.jsxParseElement();
        } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
          this.replaceToken(140);
          return this.jsxParseElement();
        } else {
          return super.parseExprAtom(refExpressionErrors);
        }
      }
      skipSpace() {
        const curContext = this.curContext();
        if (!curContext.preserveSpace)
          super.skipSpace();
      }
      getTokenFromCode(code2) {
        const context = this.curContext();
        if (context === types3.j_expr) {
          this.jsxReadToken();
          return;
        }
        if (context === types3.j_oTag || context === types3.j_cTag) {
          if (isIdentifierStart3(code2)) {
            this.jsxReadWord();
            return;
          }
          if (code2 === 62) {
            ++this.state.pos;
            this.finishToken(141);
            return;
          }
          if ((code2 === 34 || code2 === 39) && context === types3.j_oTag) {
            this.jsxReadString(code2);
            return;
          }
        }
        if (code2 === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
          ++this.state.pos;
          this.finishToken(140);
          return;
        }
        super.getTokenFromCode(code2);
      }
      updateContext(prevType) {
        const {
          context,
          type
        } = this.state;
        if (type === 56 && prevType === 140) {
          context.splice(-2, 2, types3.j_cTag);
          this.state.canStartJSXElement = false;
        } else if (type === 140) {
          context.push(types3.j_oTag);
        } else if (type === 141) {
          const out = context[context.length - 1];
          if (out === types3.j_oTag && prevType === 56 || out === types3.j_cTag) {
            context.pop();
            this.state.canStartJSXElement = context[context.length - 1] === types3.j_expr;
          } else {
            this.setContext(types3.j_expr);
            this.state.canStartJSXElement = true;
          }
        } else {
          this.state.canStartJSXElement = tokenComesBeforeExpression(type);
        }
      }
    };
    var TypeScriptScope = class extends Scope6 {
      constructor(...args) {
        super(...args);
        this.types = /* @__PURE__ */ new Set();
        this.enums = /* @__PURE__ */ new Set();
        this.constEnums = /* @__PURE__ */ new Set();
        this.classes = /* @__PURE__ */ new Set();
        this.exportOnlyBindings = /* @__PURE__ */ new Set();
      }
    };
    var TypeScriptScopeHandler = class extends ScopeHandler {
      constructor(...args) {
        super(...args);
        this.importsStack = [];
      }
      createScope(flags) {
        this.importsStack.push(/* @__PURE__ */ new Set());
        return new TypeScriptScope(flags);
      }
      enter(flags) {
        if (flags == SCOPE_TS_MODULE) {
          this.importsStack.push(/* @__PURE__ */ new Set());
        }
        super.enter(flags);
      }
      exit() {
        const flags = super.exit();
        if (flags == SCOPE_TS_MODULE) {
          this.importsStack.pop();
        }
        return flags;
      }
      hasImport(name2, allowShadow) {
        const len = this.importsStack.length;
        if (this.importsStack[len - 1].has(name2)) {
          return true;
        }
        if (!allowShadow && len > 1) {
          for (let i = 0; i < len - 1; i++) {
            if (this.importsStack[i].has(name2))
              return true;
          }
        }
        return false;
      }
      declareName(name2, bindingType, loc) {
        if (bindingType & BIND_FLAGS_TS_IMPORT) {
          if (this.hasImport(name2, true)) {
            this.parser.raise(Errors.VarRedeclaration, {
              at: loc,
              identifierName: name2
            });
          }
          this.importsStack[this.importsStack.length - 1].add(name2);
          return;
        }
        const scope = this.currentScope();
        if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {
          this.maybeExportDefined(scope, name2);
          scope.exportOnlyBindings.add(name2);
          return;
        }
        super.declareName(name2, bindingType, loc);
        if (bindingType & BIND_KIND_TYPE) {
          if (!(bindingType & BIND_KIND_VALUE)) {
            this.checkRedeclarationInScope(scope, name2, bindingType, loc);
            this.maybeExportDefined(scope, name2);
          }
          scope.types.add(name2);
        }
        if (bindingType & BIND_FLAGS_TS_ENUM)
          scope.enums.add(name2);
        if (bindingType & BIND_FLAGS_TS_CONST_ENUM)
          scope.constEnums.add(name2);
        if (bindingType & BIND_FLAGS_CLASS)
          scope.classes.add(name2);
      }
      isRedeclaredInScope(scope, name2, bindingType) {
        if (scope.enums.has(name2)) {
          if (bindingType & BIND_FLAGS_TS_ENUM) {
            const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM);
            const wasConst = scope.constEnums.has(name2);
            return isConst !== wasConst;
          }
          return true;
        }
        if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name2)) {
          if (scope.lexical.has(name2)) {
            return !!(bindingType & BIND_KIND_VALUE);
          } else {
            return false;
          }
        }
        if (bindingType & BIND_KIND_TYPE && scope.types.has(name2)) {
          return true;
        }
        return super.isRedeclaredInScope(scope, name2, bindingType);
      }
      checkLocalExport(id) {
        const {
          name: name2
        } = id;
        if (this.hasImport(name2))
          return;
        const len = this.scopeStack.length;
        for (let i = len - 1; i >= 0; i--) {
          const scope = this.scopeStack[i];
          if (scope.types.has(name2) || scope.exportOnlyBindings.has(name2))
            return;
        }
        super.checkLocalExport(id);
      }
    };
    var getOwn$1 = (object, key2) => Object.hasOwnProperty.call(object, key2) && object[key2];
    var unwrapParenthesizedExpression = (node2) => {
      return node2.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node2.expression) : node2;
    };
    var LValParser = class extends NodeUtils {
      toAssignable(node2, isLHS = false) {
        var _node$extra, _node$extra3;
        let parenthesized = void 0;
        if (node2.type === "ParenthesizedExpression" || (_node$extra = node2.extra) != null && _node$extra.parenthesized) {
          parenthesized = unwrapParenthesizedExpression(node2);
          if (isLHS) {
            if (parenthesized.type === "Identifier") {
              this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
                at: node2
              });
            } else if (parenthesized.type !== "MemberExpression") {
              this.raise(Errors.InvalidParenthesizedAssignment, {
                at: node2
              });
            }
          } else {
            this.raise(Errors.InvalidParenthesizedAssignment, {
              at: node2
            });
          }
        }
        switch (node2.type) {
          case "Identifier":
          case "ObjectPattern":
          case "ArrayPattern":
          case "AssignmentPattern":
          case "RestElement":
            break;
          case "ObjectExpression":
            node2.type = "ObjectPattern";
            for (let i = 0, length = node2.properties.length, last = length - 1; i < length; i++) {
              var _node$extra2;
              const prop = node2.properties[i];
              const isLast = i === last;
              this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
              if (isLast && prop.type === "RestElement" && (_node$extra2 = node2.extra) != null && _node$extra2.trailingCommaLoc) {
                this.raise(Errors.RestTrailingComma, {
                  at: node2.extra.trailingCommaLoc
                });
              }
            }
            break;
          case "ObjectProperty": {
            const {
              key: key2,
              value: value2
            } = node2;
            if (this.isPrivateName(key2)) {
              this.classScope.usePrivateName(this.getPrivateNameSV(key2), key2.loc.start);
            }
            this.toAssignable(value2, isLHS);
            break;
          }
          case "SpreadElement": {
            throw new Error("Internal @babel/parser error (this is a bug, please report it). SpreadElement should be converted by .toAssignable's caller.");
          }
          case "ArrayExpression":
            node2.type = "ArrayPattern";
            this.toAssignableList(node2.elements, (_node$extra3 = node2.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
            break;
          case "AssignmentExpression":
            if (node2.operator !== "=") {
              this.raise(Errors.MissingEqInAssignment, {
                at: node2.left.loc.end
              });
            }
            node2.type = "AssignmentPattern";
            delete node2.operator;
            this.toAssignable(node2.left, isLHS);
            break;
          case "ParenthesizedExpression":
            this.toAssignable(parenthesized, isLHS);
            break;
        }
      }
      toAssignableObjectExpressionProp(prop, isLast, isLHS) {
        if (prop.type === "ObjectMethod") {
          this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
            at: prop.key
          });
        } else if (prop.type === "SpreadElement") {
          prop.type = "RestElement";
          const arg = prop.argument;
          this.checkToRestConversion(arg, false);
          this.toAssignable(arg, isLHS);
          if (!isLast) {
            this.raise(Errors.RestTrailingComma, {
              at: prop
            });
          }
        } else {
          this.toAssignable(prop, isLHS);
        }
      }
      toAssignableList(exprList, trailingCommaLoc, isLHS) {
        const end = exprList.length - 1;
        for (let i = 0; i <= end; i++) {
          const elt = exprList[i];
          if (!elt)
            continue;
          if (elt.type === "SpreadElement") {
            elt.type = "RestElement";
            const arg = elt.argument;
            this.checkToRestConversion(arg, true);
            this.toAssignable(arg, isLHS);
          } else {
            this.toAssignable(elt, isLHS);
          }
          if (elt.type === "RestElement") {
            if (i < end) {
              this.raise(Errors.RestTrailingComma, {
                at: elt
              });
            } else if (trailingCommaLoc) {
              this.raise(Errors.RestTrailingComma, {
                at: trailingCommaLoc
              });
            }
          }
        }
      }
      isAssignable(node2, isBinding) {
        switch (node2.type) {
          case "Identifier":
          case "ObjectPattern":
          case "ArrayPattern":
          case "AssignmentPattern":
          case "RestElement":
            return true;
          case "ObjectExpression": {
            const last = node2.properties.length - 1;
            return node2.properties.every((prop, i) => {
              return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop);
            });
          }
          case "ObjectProperty":
            return this.isAssignable(node2.value);
          case "SpreadElement":
            return this.isAssignable(node2.argument);
          case "ArrayExpression":
            return node2.elements.every((element2) => element2 === null || this.isAssignable(element2));
          case "AssignmentExpression":
            return node2.operator === "=";
          case "ParenthesizedExpression":
            return this.isAssignable(node2.expression);
          case "MemberExpression":
          case "OptionalMemberExpression":
            return !isBinding;
          default:
            return false;
        }
      }
      toReferencedList(exprList, isParenthesizedExpr) {
        return exprList;
      }
      toReferencedListDeep(exprList, isParenthesizedExpr) {
        this.toReferencedList(exprList, isParenthesizedExpr);
        for (const expr of exprList) {
          if ((expr == null ? void 0 : expr.type) === "ArrayExpression") {
            this.toReferencedListDeep(expr.elements);
          }
        }
      }
      parseSpread(refExpressionErrors) {
        const node2 = this.startNode();
        this.next();
        node2.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, void 0);
        return this.finishNode(node2, "SpreadElement");
      }
      parseRestBinding() {
        const node2 = this.startNode();
        this.next();
        node2.argument = this.parseBindingAtom();
        return this.finishNode(node2, "RestElement");
      }
      parseBindingAtom() {
        switch (this.state.type) {
          case 0: {
            const node2 = this.startNode();
            this.next();
            node2.elements = this.parseBindingList(3, 93, 1);
            return this.finishNode(node2, "ArrayPattern");
          }
          case 5:
            return this.parseObjectLike(8, true);
        }
        return this.parseIdentifier();
      }
      parseBindingList(close, closeCharCode, flags) {
        const allowEmpty = flags & 1;
        const elts = [];
        let first = true;
        while (!this.eat(close)) {
          if (first) {
            first = false;
          } else {
            this.expect(12);
          }
          if (allowEmpty && this.match(12)) {
            elts.push(null);
          } else if (this.eat(close)) {
            break;
          } else if (this.match(21)) {
            elts.push(this.parseAssignableListItemTypes(this.parseRestBinding(), flags));
            if (!this.checkCommaAfterRest(closeCharCode)) {
              this.expect(close);
              break;
            }
          } else {
            const decorators = [];
            if (this.match(26) && this.hasPlugin("decorators")) {
              this.raise(Errors.UnsupportedParameterDecorator, {
                at: this.state.startLoc
              });
            }
            while (this.match(26)) {
              decorators.push(this.parseDecorator());
            }
            elts.push(this.parseAssignableListItem(flags, decorators));
          }
        }
        return elts;
      }
      parseBindingRestProperty(prop) {
        this.next();
        prop.argument = this.parseIdentifier();
        this.checkCommaAfterRest(125);
        return this.finishNode(prop, "RestElement");
      }
      parseBindingProperty() {
        const prop = this.startNode();
        const {
          type,
          startLoc
        } = this.state;
        if (type === 21) {
          return this.parseBindingRestProperty(prop);
        } else if (type === 136) {
          this.expectPlugin("destructuringPrivate", startLoc);
          this.classScope.usePrivateName(this.state.value, startLoc);
          prop.key = this.parsePrivateName();
        } else {
          this.parsePropertyName(prop);
        }
        prop.method = false;
        return this.parseObjPropValue(prop, startLoc, false, false, true, false);
      }
      parseAssignableListItem(flags, decorators) {
        const left = this.parseMaybeDefault();
        this.parseAssignableListItemTypes(left, flags);
        const elt = this.parseMaybeDefault(left.loc.start, left);
        if (decorators.length) {
          left.decorators = decorators;
        }
        return elt;
      }
      parseAssignableListItemTypes(param, flags) {
        return param;
      }
      parseMaybeDefault(startLoc, left) {
        var _startLoc, _left;
        (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
        left = (_left = left) != null ? _left : this.parseBindingAtom();
        if (!this.eat(29))
          return left;
        const node2 = this.startNodeAt(startLoc);
        node2.left = left;
        node2.right = this.parseMaybeAssignAllowIn();
        return this.finishNode(node2, "AssignmentPattern");
      }
      isValidLVal(type, isUnparenthesizedInAssign, binding) {
        return getOwn$1({
          AssignmentPattern: "left",
          RestElement: "argument",
          ObjectProperty: "value",
          ParenthesizedExpression: "expression",
          ArrayPattern: "elements",
          ObjectPattern: "properties"
        }, type);
      }
      checkLVal(expression, {
        in: ancestor,
        binding = BIND_NONE3,
        checkClashes = false,
        strictModeChanged = false,
        hasParenthesizedAncestor = false
      }) {
        var _expression$extra;
        const type = expression.type;
        if (this.isObjectMethod(expression))
          return;
        if (type === "MemberExpression") {
          if (binding !== BIND_NONE3) {
            this.raise(Errors.InvalidPropertyBindingPattern, {
              at: expression
            });
          }
          return;
        }
        if (type === "Identifier") {
          this.checkIdentifier(expression, binding, strictModeChanged);
          const {
            name: name2
          } = expression;
          if (checkClashes) {
            if (checkClashes.has(name2)) {
              this.raise(Errors.ParamDupe, {
                at: expression
              });
            } else {
              checkClashes.add(name2);
            }
          }
          return;
        }
        const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
        if (validity === true)
          return;
        if (validity === false) {
          const ParseErrorClass = binding === BIND_NONE3 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
          this.raise(ParseErrorClass, {
            at: expression,
            ancestor
          });
          return;
        }
        const [key2, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
        const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" || type === "ParenthesizedExpression" ? {
          type
        } : ancestor;
        for (const child of [].concat(expression[key2])) {
          if (child) {
            this.checkLVal(child, {
              in: nextAncestor,
              binding,
              checkClashes,
              strictModeChanged,
              hasParenthesizedAncestor: isParenthesizedExpression
            });
          }
        }
      }
      checkIdentifier(at3, bindingType, strictModeChanged = false) {
        if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at3.name, this.inModule) : isStrictBindOnlyReservedWord(at3.name))) {
          if (bindingType === BIND_NONE3) {
            this.raise(Errors.StrictEvalArguments, {
              at: at3,
              referenceName: at3.name
            });
          } else {
            this.raise(Errors.StrictEvalArgumentsBinding, {
              at: at3,
              bindingName: at3.name
            });
          }
        }
        if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at3.name === "let") {
          this.raise(Errors.LetInLexicalBinding, {
            at: at3
          });
        }
        if (!(bindingType & BIND_NONE3)) {
          this.declareNameFromIdentifier(at3, bindingType);
        }
      }
      declareNameFromIdentifier(identifier, binding) {
        this.scope.declareName(identifier.name, binding, identifier.loc.start);
      }
      checkToRestConversion(node2, allowPattern) {
        switch (node2.type) {
          case "ParenthesizedExpression":
            this.checkToRestConversion(node2.expression, allowPattern);
            break;
          case "Identifier":
          case "MemberExpression":
            break;
          case "ArrayExpression":
          case "ObjectExpression":
            if (allowPattern)
              break;
          default:
            this.raise(Errors.InvalidRestAssignmentPattern, {
              at: node2
            });
        }
      }
      checkCommaAfterRest(close) {
        if (!this.match(12)) {
          return false;
        }
        this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
          at: this.state.startLoc
        });
        return true;
      }
    };
    var getOwn = (object, key2) => Object.hasOwnProperty.call(object, key2) && object[key2];
    function nonNull(x) {
      if (x == null) {
        throw new Error(`Unexpected ${x} value.`);
      }
      return x;
    }
    function assert(x) {
      if (!x) {
        throw new Error("Assert fail");
      }
    }
    var TSErrors = ParseErrorEnum`typescript`({
      AbstractMethodHasImplementation: ({
        methodName
      }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
      AbstractPropertyHasInitializer: ({
        propertyName
      }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
      AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
      AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
      AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
      ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
      ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
      ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
      ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
      DeclareAccessor: ({
        kind
      }) => `'declare' is not allowed in ${kind}ters.`,
      DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
      DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
      DuplicateAccessibilityModifier: ({
        modifier
      }) => `Accessibility modifier already seen.`,
      DuplicateModifier: ({
        modifier
      }) => `Duplicate modifier: '${modifier}'.`,
      EmptyHeritageClauseType: ({
        token: token2
      }) => `'${token2}' list cannot be empty.`,
      EmptyTypeArguments: "Type argument list cannot be empty.",
      EmptyTypeParameters: "Type parameter list cannot be empty.",
      ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
      ImportAliasHasImportType: "An import alias can not use 'import type'.",
      ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
      IncompatibleModifiers: ({
        modifiers
      }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
      IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
      IndexSignatureHasAccessibility: ({
        modifier
      }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
      IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
      IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
      IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
      InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
      InvalidModifierOnTypeMember: ({
        modifier
      }) => `'${modifier}' modifier cannot appear on a type member.`,
      InvalidModifierOnTypeParameter: ({
        modifier
      }) => `'${modifier}' modifier cannot appear on a type parameter.`,
      InvalidModifierOnTypeParameterPositions: ({
        modifier
      }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
      InvalidModifiersOrder: ({
        orderedModifiers
      }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
      InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
      InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
      MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
      MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
      NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
      NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
      OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
      OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
      PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
      PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
      PrivateElementHasAccessibility: ({
        modifier
      }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
      ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
      ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
      ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
      SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
      SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
      SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
      SingleTypeParameterWithoutTrailingComma: ({
        typeParameterName
      }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
      StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
      TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
      TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
      TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
      TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
      TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
      UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
      UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
      UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
      UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
      UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
      UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
      UnsupportedSignatureParameterKind: ({
        type
      }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
    });
    function keywordTypeFromName(value2) {
      switch (value2) {
        case "any":
          return "TSAnyKeyword";
        case "boolean":
          return "TSBooleanKeyword";
        case "bigint":
          return "TSBigIntKeyword";
        case "never":
          return "TSNeverKeyword";
        case "number":
          return "TSNumberKeyword";
        case "object":
          return "TSObjectKeyword";
        case "string":
          return "TSStringKeyword";
        case "symbol":
          return "TSSymbolKeyword";
        case "undefined":
          return "TSUndefinedKeyword";
        case "unknown":
          return "TSUnknownKeyword";
        default:
          return void 0;
      }
    }
    function tsIsAccessModifier(modifier) {
      return modifier === "private" || modifier === "public" || modifier === "protected";
    }
    function tsIsVarianceAnnotations(modifier) {
      return modifier === "in" || modifier === "out";
    }
    var typescript = (superClass) => class TypeScriptParserMixin extends superClass {
      constructor(...args) {
        super(...args);
        this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
          allowedModifiers: ["in", "out"],
          disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"],
          errorTemplate: TSErrors.InvalidModifierOnTypeParameter
        });
        this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
          allowedModifiers: ["const"],
          disallowedModifiers: ["in", "out"],
          errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
        });
        this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
          allowedModifiers: ["in", "out", "const"],
          disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
          errorTemplate: TSErrors.InvalidModifierOnTypeParameter
        });
      }
      getScopeHandler() {
        return TypeScriptScopeHandler;
      }
      tsIsIdentifier() {
        return tokenIsIdentifier(this.state.type);
      }
      tsTokenCanFollowModifier() {
        return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(136) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
      }
      tsNextTokenCanFollowModifier() {
        this.next();
        return this.tsTokenCanFollowModifier();
      }
      tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
        if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
          return void 0;
        }
        const modifier = this.state.value;
        if (allowedModifiers.indexOf(modifier) !== -1) {
          if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
            return void 0;
          }
          if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
            return modifier;
          }
        }
        return void 0;
      }
      tsParseModifiers({
        allowedModifiers,
        disallowedModifiers,
        stopOnStartOfClassStaticBlock,
        errorTemplate = TSErrors.InvalidModifierOnTypeMember
      }, modified) {
        const enforceOrder = (loc, modifier, before, after) => {
          if (modifier === before && modified[after]) {
            this.raise(TSErrors.InvalidModifiersOrder, {
              at: loc,
              orderedModifiers: [before, after]
            });
          }
        };
        const incompatible = (loc, modifier, mod1, mod2) => {
          if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
            this.raise(TSErrors.IncompatibleModifiers, {
              at: loc,
              modifiers: [mod1, mod2]
            });
          }
        };
        for (; ; ) {
          const {
            startLoc
          } = this.state;
          const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
          if (!modifier)
            break;
          if (tsIsAccessModifier(modifier)) {
            if (modified.accessibility) {
              this.raise(TSErrors.DuplicateAccessibilityModifier, {
                at: startLoc,
                modifier
              });
            } else {
              enforceOrder(startLoc, modifier, modifier, "override");
              enforceOrder(startLoc, modifier, modifier, "static");
              enforceOrder(startLoc, modifier, modifier, "readonly");
              modified.accessibility = modifier;
            }
          } else if (tsIsVarianceAnnotations(modifier)) {
            if (modified[modifier]) {
              this.raise(TSErrors.DuplicateModifier, {
                at: startLoc,
                modifier
              });
            }
            modified[modifier] = true;
            enforceOrder(startLoc, modifier, "in", "out");
          } else {
            if (Object.hasOwnProperty.call(modified, modifier)) {
              this.raise(TSErrors.DuplicateModifier, {
                at: startLoc,
                modifier
              });
            } else {
              enforceOrder(startLoc, modifier, "static", "readonly");
              enforceOrder(startLoc, modifier, "static", "override");
              enforceOrder(startLoc, modifier, "override", "readonly");
              enforceOrder(startLoc, modifier, "abstract", "override");
              incompatible(startLoc, modifier, "declare", "override");
              incompatible(startLoc, modifier, "static", "abstract");
            }
            modified[modifier] = true;
          }
          if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
            this.raise(errorTemplate, {
              at: startLoc,
              modifier
            });
          }
        }
      }
      tsIsListTerminator(kind) {
        switch (kind) {
          case "EnumMembers":
          case "TypeMembers":
            return this.match(8);
          case "HeritageClauseElement":
            return this.match(5);
          case "TupleElementTypes":
            return this.match(3);
          case "TypeParametersOrArguments":
            return this.match(48);
        }
      }
      tsParseList(kind, parseElement) {
        const result = [];
        while (!this.tsIsListTerminator(kind)) {
          result.push(parseElement());
        }
        return result;
      }
      tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
        return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
      }
      tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
        const result = [];
        let trailingCommaPos = -1;
        for (; ; ) {
          if (this.tsIsListTerminator(kind)) {
            break;
          }
          trailingCommaPos = -1;
          const element2 = parseElement();
          if (element2 == null) {
            return void 0;
          }
          result.push(element2);
          if (this.eat(12)) {
            trailingCommaPos = this.state.lastTokStart;
            continue;
          }
          if (this.tsIsListTerminator(kind)) {
            break;
          }
          if (expectSuccess) {
            this.expect(12);
          }
          return void 0;
        }
        if (refTrailingCommaPos) {
          refTrailingCommaPos.value = trailingCommaPos;
        }
        return result;
      }
      tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
        if (!skipFirstToken) {
          if (bracket) {
            this.expect(0);
          } else {
            this.expect(47);
          }
        }
        const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
        if (bracket) {
          this.expect(3);
        } else {
          this.expect(48);
        }
        return result;
      }
      tsParseImportType() {
        const node2 = this.startNode();
        this.expect(83);
        this.expect(10);
        if (!this.match(131)) {
          this.raise(TSErrors.UnsupportedImportTypeArgument, {
            at: this.state.startLoc
          });
        }
        node2.argument = super.parseExprAtom();
        this.expect(11);
        if (this.eat(16)) {
          node2.qualifier = this.tsParseEntityName();
        }
        if (this.match(47)) {
          node2.typeParameters = this.tsParseTypeArguments();
        }
        return this.finishNode(node2, "TSImportType");
      }
      tsParseEntityName(allowReservedWords = true) {
        let entity = this.parseIdentifier(allowReservedWords);
        while (this.eat(16)) {
          const node2 = this.startNodeAtNode(entity);
          node2.left = entity;
          node2.right = this.parseIdentifier(allowReservedWords);
          entity = this.finishNode(node2, "TSQualifiedName");
        }
        return entity;
      }
      tsParseTypeReference() {
        const node2 = this.startNode();
        node2.typeName = this.tsParseEntityName();
        if (!this.hasPrecedingLineBreak() && this.match(47)) {
          node2.typeParameters = this.tsParseTypeArguments();
        }
        return this.finishNode(node2, "TSTypeReference");
      }
      tsParseThisTypePredicate(lhs) {
        this.next();
        const node2 = this.startNodeAtNode(lhs);
        node2.parameterName = lhs;
        node2.typeAnnotation = this.tsParseTypeAnnotation(false);
        node2.asserts = false;
        return this.finishNode(node2, "TSTypePredicate");
      }
      tsParseThisTypeNode() {
        const node2 = this.startNode();
        this.next();
        return this.finishNode(node2, "TSThisType");
      }
      tsParseTypeQuery() {
        const node2 = this.startNode();
        this.expect(87);
        if (this.match(83)) {
          node2.exprName = this.tsParseImportType();
        } else {
          node2.exprName = this.tsParseEntityName();
        }
        if (!this.hasPrecedingLineBreak() && this.match(47)) {
          node2.typeParameters = this.tsParseTypeArguments();
        }
        return this.finishNode(node2, "TSTypeQuery");
      }
      tsParseTypeParameter(parseModifiers) {
        const node2 = this.startNode();
        parseModifiers(node2);
        node2.name = this.tsParseTypeParameterName();
        node2.constraint = this.tsEatThenParseType(81);
        node2.default = this.tsEatThenParseType(29);
        return this.finishNode(node2, "TSTypeParameter");
      }
      tsTryParseTypeParameters(parseModifiers) {
        if (this.match(47)) {
          return this.tsParseTypeParameters(parseModifiers);
        }
      }
      tsParseTypeParameters(parseModifiers) {
        const node2 = this.startNode();
        if (this.match(47) || this.match(140)) {
          this.next();
        } else {
          this.unexpected();
        }
        const refTrailingCommaPos = {
          value: -1
        };
        node2.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
        if (node2.params.length === 0) {
          this.raise(TSErrors.EmptyTypeParameters, {
            at: node2
          });
        }
        if (refTrailingCommaPos.value !== -1) {
          this.addExtra(node2, "trailingComma", refTrailingCommaPos.value);
        }
        return this.finishNode(node2, "TSTypeParameterDeclaration");
      }
      tsFillSignature(returnToken, signature) {
        const returnTokenRequired = returnToken === 19;
        const paramsKey = "parameters";
        const returnTypeKey = "typeAnnotation";
        signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        this.expect(10);
        signature[paramsKey] = this.tsParseBindingListForSignature();
        if (returnTokenRequired) {
          signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
        } else if (this.match(returnToken)) {
          signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
        }
      }
      tsParseBindingListForSignature() {
        return super.parseBindingList(11, 41, 2).map((pattern) => {
          if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
            this.raise(TSErrors.UnsupportedSignatureParameterKind, {
              at: pattern,
              type: pattern.type
            });
          }
          return pattern;
        });
      }
      tsParseTypeMemberSemicolon() {
        if (!this.eat(12) && !this.isLineTerminator()) {
          this.expect(13);
        }
      }
      tsParseSignatureMember(kind, node2) {
        this.tsFillSignature(14, node2);
        this.tsParseTypeMemberSemicolon();
        return this.finishNode(node2, kind);
      }
      tsIsUnambiguouslyIndexSignature() {
        this.next();
        if (tokenIsIdentifier(this.state.type)) {
          this.next();
          return this.match(14);
        }
        return false;
      }
      tsTryParseIndexSignature(node2) {
        if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
          return void 0;
        }
        this.expect(0);
        const id = this.parseIdentifier();
        id.typeAnnotation = this.tsParseTypeAnnotation();
        this.resetEndLocation(id);
        this.expect(3);
        node2.parameters = [id];
        const type = this.tsTryParseTypeAnnotation();
        if (type)
          node2.typeAnnotation = type;
        this.tsParseTypeMemberSemicolon();
        return this.finishNode(node2, "TSIndexSignature");
      }
      tsParsePropertyOrMethodSignature(node2, readonly) {
        if (this.eat(17))
          node2.optional = true;
        const nodeAny = node2;
        if (this.match(10) || this.match(47)) {
          if (readonly) {
            this.raise(TSErrors.ReadonlyForMethodSignature, {
              at: node2
            });
          }
          const method = nodeAny;
          if (method.kind && this.match(47)) {
            this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
              at: this.state.curPosition()
            });
          }
          this.tsFillSignature(14, method);
          this.tsParseTypeMemberSemicolon();
          const paramsKey = "parameters";
          const returnTypeKey = "typeAnnotation";
          if (method.kind === "get") {
            if (method[paramsKey].length > 0) {
              this.raise(Errors.BadGetterArity, {
                at: this.state.curPosition()
              });
              if (this.isThisParam(method[paramsKey][0])) {
                this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
                  at: this.state.curPosition()
                });
              }
            }
          } else if (method.kind === "set") {
            if (method[paramsKey].length !== 1) {
              this.raise(Errors.BadSetterArity, {
                at: this.state.curPosition()
              });
            } else {
              const firstParameter = method[paramsKey][0];
              if (this.isThisParam(firstParameter)) {
                this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
                  at: this.state.curPosition()
                });
              }
              if (firstParameter.type === "Identifier" && firstParameter.optional) {
                this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
                  at: this.state.curPosition()
                });
              }
              if (firstParameter.type === "RestElement") {
                this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
                  at: this.state.curPosition()
                });
              }
            }
            if (method[returnTypeKey]) {
              this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
                at: method[returnTypeKey]
              });
            }
          } else {
            method.kind = "method";
          }
          return this.finishNode(method, "TSMethodSignature");
        } else {
          const property = nodeAny;
          if (readonly)
            property.readonly = true;
          const type = this.tsTryParseTypeAnnotation();
          if (type)
            property.typeAnnotation = type;
          this.tsParseTypeMemberSemicolon();
          return this.finishNode(property, "TSPropertySignature");
        }
      }
      tsParseTypeMember() {
        const node2 = this.startNode();
        if (this.match(10) || this.match(47)) {
          return this.tsParseSignatureMember("TSCallSignatureDeclaration", node2);
        }
        if (this.match(77)) {
          const id = this.startNode();
          this.next();
          if (this.match(10) || this.match(47)) {
            return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node2);
          } else {
            node2.key = this.createIdentifier(id, "new");
            return this.tsParsePropertyOrMethodSignature(node2, false);
          }
        }
        this.tsParseModifiers({
          allowedModifiers: ["readonly"],
          disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
        }, node2);
        const idx = this.tsTryParseIndexSignature(node2);
        if (idx) {
          return idx;
        }
        super.parsePropertyName(node2);
        if (!node2.computed && node2.key.type === "Identifier" && (node2.key.name === "get" || node2.key.name === "set") && this.tsTokenCanFollowModifier()) {
          node2.kind = node2.key.name;
          super.parsePropertyName(node2);
        }
        return this.tsParsePropertyOrMethodSignature(node2, !!node2.readonly);
      }
      tsParseTypeLiteral() {
        const node2 = this.startNode();
        node2.members = this.tsParseObjectTypeMembers();
        return this.finishNode(node2, "TSTypeLiteral");
      }
      tsParseObjectTypeMembers() {
        this.expect(5);
        const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
        this.expect(8);
        return members;
      }
      tsIsStartOfMappedType() {
        this.next();
        if (this.eat(53)) {
          return this.isContextual(120);
        }
        if (this.isContextual(120)) {
          this.next();
        }
        if (!this.match(0)) {
          return false;
        }
        this.next();
        if (!this.tsIsIdentifier()) {
          return false;
        }
        this.next();
        return this.match(58);
      }
      tsParseMappedTypeParameter() {
        const node2 = this.startNode();
        node2.name = this.tsParseTypeParameterName();
        node2.constraint = this.tsExpectThenParseType(58);
        return this.finishNode(node2, "TSTypeParameter");
      }
      tsParseMappedType() {
        const node2 = this.startNode();
        this.expect(5);
        if (this.match(53)) {
          node2.readonly = this.state.value;
          this.next();
          this.expectContextual(120);
        } else if (this.eatContextual(120)) {
          node2.readonly = true;
        }
        this.expect(0);
        node2.typeParameter = this.tsParseMappedTypeParameter();
        node2.nameType = this.eatContextual(93) ? this.tsParseType() : null;
        this.expect(3);
        if (this.match(53)) {
          node2.optional = this.state.value;
          this.next();
          this.expect(17);
        } else if (this.eat(17)) {
          node2.optional = true;
        }
        node2.typeAnnotation = this.tsTryParseType();
        this.semicolon();
        this.expect(8);
        return this.finishNode(node2, "TSMappedType");
      }
      tsParseTupleType() {
        const node2 = this.startNode();
        node2.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
        let seenOptionalElement = false;
        let labeledElements = null;
        node2.elementTypes.forEach((elementNode) => {
          var _labeledElements;
          const {
            type
          } = elementNode;
          if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
            this.raise(TSErrors.OptionalTypeBeforeRequired, {
              at: elementNode
            });
          }
          seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
          let checkType = type;
          if (type === "TSRestType") {
            elementNode = elementNode.typeAnnotation;
            checkType = elementNode.type;
          }
          const isLabeled = checkType === "TSNamedTupleMember";
          (_labeledElements = labeledElements) != null ? _labeledElements : labeledElements = isLabeled;
          if (labeledElements !== isLabeled) {
            this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
              at: elementNode
            });
          }
        });
        return this.finishNode(node2, "TSTupleType");
      }
      tsParseTupleElementType() {
        const {
          startLoc
        } = this.state;
        const rest = this.eat(21);
        let labeled;
        let label;
        let optional;
        let type;
        const isWord = tokenIsKeywordOrIdentifier(this.state.type);
        const chAfterWord = isWord ? this.lookaheadCharCode() : null;
        if (chAfterWord === 58) {
          labeled = true;
          optional = false;
          label = this.parseIdentifier(true);
          this.expect(14);
          type = this.tsParseType();
        } else if (chAfterWord === 63) {
          optional = true;
          const startLoc2 = this.state.startLoc;
          const wordName = this.state.value;
          const typeOrLabel = this.tsParseNonArrayType();
          if (this.lookaheadCharCode() === 58) {
            labeled = true;
            label = this.createIdentifier(this.startNodeAt(startLoc2), wordName);
            this.expect(17);
            this.expect(14);
            type = this.tsParseType();
          } else {
            labeled = false;
            type = typeOrLabel;
            this.expect(17);
          }
        } else {
          type = this.tsParseType();
          optional = this.eat(17);
          labeled = this.eat(14);
        }
        if (labeled) {
          let labeledNode;
          if (label) {
            labeledNode = this.startNodeAtNode(label);
            labeledNode.optional = optional;
            labeledNode.label = label;
            labeledNode.elementType = type;
            if (this.eat(17)) {
              labeledNode.optional = true;
              this.raise(TSErrors.TupleOptionalAfterType, {
                at: this.state.lastTokStartLoc
              });
            }
          } else {
            labeledNode = this.startNodeAtNode(type);
            labeledNode.optional = optional;
            this.raise(TSErrors.InvalidTupleMemberLabel, {
              at: type
            });
            labeledNode.label = type;
            labeledNode.elementType = this.tsParseType();
          }
          type = this.finishNode(labeledNode, "TSNamedTupleMember");
        } else if (optional) {
          const optionalTypeNode = this.startNodeAtNode(type);
          optionalTypeNode.typeAnnotation = type;
          type = this.finishNode(optionalTypeNode, "TSOptionalType");
        }
        if (rest) {
          const restNode = this.startNodeAt(startLoc);
          restNode.typeAnnotation = type;
          type = this.finishNode(restNode, "TSRestType");
        }
        return type;
      }
      tsParseParenthesizedType() {
        const node2 = this.startNode();
        this.expect(10);
        node2.typeAnnotation = this.tsParseType();
        this.expect(11);
        return this.finishNode(node2, "TSParenthesizedType");
      }
      tsParseFunctionOrConstructorType(type, abstract) {
        const node2 = this.startNode();
        if (type === "TSConstructorType") {
          node2.abstract = !!abstract;
          if (abstract)
            this.next();
          this.next();
        }
        this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node2));
        return this.finishNode(node2, type);
      }
      tsParseLiteralTypeNode() {
        const node2 = this.startNode();
        node2.literal = (() => {
          switch (this.state.type) {
            case 132:
            case 133:
            case 131:
            case 85:
            case 86:
              return super.parseExprAtom();
            default:
              this.unexpected();
          }
        })();
        return this.finishNode(node2, "TSLiteralType");
      }
      tsParseTemplateLiteralType() {
        const node2 = this.startNode();
        node2.literal = super.parseTemplate(false);
        return this.finishNode(node2, "TSLiteralType");
      }
      parseTemplateSubstitution() {
        if (this.state.inType)
          return this.tsParseType();
        return super.parseTemplateSubstitution();
      }
      tsParseThisTypeOrThisTypePredicate() {
        const thisKeyword = this.tsParseThisTypeNode();
        if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
          return this.tsParseThisTypePredicate(thisKeyword);
        } else {
          return thisKeyword;
        }
      }
      tsParseNonArrayType() {
        switch (this.state.type) {
          case 131:
          case 132:
          case 133:
          case 85:
          case 86:
            return this.tsParseLiteralTypeNode();
          case 53:
            if (this.state.value === "-") {
              const node2 = this.startNode();
              const nextToken = this.lookahead();
              if (nextToken.type !== 132 && nextToken.type !== 133) {
                this.unexpected();
              }
              node2.literal = this.parseMaybeUnary();
              return this.finishNode(node2, "TSLiteralType");
            }
            break;
          case 78:
            return this.tsParseThisTypeOrThisTypePredicate();
          case 87:
            return this.tsParseTypeQuery();
          case 83:
            return this.tsParseImportType();
          case 5:
            return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
          case 0:
            return this.tsParseTupleType();
          case 10:
            return this.tsParseParenthesizedType();
          case 25:
          case 24:
            return this.tsParseTemplateLiteralType();
          default: {
            const {
              type
            } = this.state;
            if (tokenIsIdentifier(type) || type === 88 || type === 84) {
              const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
              if (nodeType !== void 0 && this.lookaheadCharCode() !== 46) {
                const node2 = this.startNode();
                this.next();
                return this.finishNode(node2, nodeType);
              }
              return this.tsParseTypeReference();
            }
          }
        }
        this.unexpected();
      }
      tsParseArrayTypeOrHigher() {
        let type = this.tsParseNonArrayType();
        while (!this.hasPrecedingLineBreak() && this.eat(0)) {
          if (this.match(3)) {
            const node2 = this.startNodeAtNode(type);
            node2.elementType = type;
            this.expect(3);
            type = this.finishNode(node2, "TSArrayType");
          } else {
            const node2 = this.startNodeAtNode(type);
            node2.objectType = type;
            node2.indexType = this.tsParseType();
            this.expect(3);
            type = this.finishNode(node2, "TSIndexedAccessType");
          }
        }
        return type;
      }
      tsParseTypeOperator() {
        const node2 = this.startNode();
        const operator = this.state.value;
        this.next();
        node2.operator = operator;
        node2.typeAnnotation = this.tsParseTypeOperatorOrHigher();
        if (operator === "readonly") {
          this.tsCheckTypeAnnotationForReadOnly(node2);
        }
        return this.finishNode(node2, "TSTypeOperator");
      }
      tsCheckTypeAnnotationForReadOnly(node2) {
        switch (node2.typeAnnotation.type) {
          case "TSTupleType":
          case "TSArrayType":
            return;
          default:
            this.raise(TSErrors.UnexpectedReadonly, {
              at: node2
            });
        }
      }
      tsParseInferType() {
        const node2 = this.startNode();
        this.expectContextual(113);
        const typeParameter = this.startNode();
        typeParameter.name = this.tsParseTypeParameterName();
        typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
        node2.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
        return this.finishNode(node2, "TSInferType");
      }
      tsParseConstraintForInferType() {
        if (this.eat(81)) {
          const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
          if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
            return constraint;
          }
        }
      }
      tsParseTypeOperatorOrHigher() {
        const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
        return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(113) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
      }
      tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
        const node2 = this.startNode();
        const hasLeadingOperator = this.eat(operator);
        const types4 = [];
        do {
          types4.push(parseConstituentType());
        } while (this.eat(operator));
        if (types4.length === 1 && !hasLeadingOperator) {
          return types4[0];
        }
        node2.types = types4;
        return this.finishNode(node2, kind);
      }
      tsParseIntersectionTypeOrHigher() {
        return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
      }
      tsParseUnionTypeOrHigher() {
        return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
      }
      tsIsStartOfFunctionType() {
        if (this.match(47)) {
          return true;
        }
        return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
      }
      tsSkipParameterStart() {
        if (tokenIsIdentifier(this.state.type) || this.match(78)) {
          this.next();
          return true;
        }
        if (this.match(5)) {
          const {
            errors
          } = this.state;
          const previousErrorCount = errors.length;
          try {
            this.parseObjectLike(8, true);
            return errors.length === previousErrorCount;
          } catch (_unused) {
            return false;
          }
        }
        if (this.match(0)) {
          this.next();
          const {
            errors
          } = this.state;
          const previousErrorCount = errors.length;
          try {
            super.parseBindingList(3, 93, 1);
            return errors.length === previousErrorCount;
          } catch (_unused2) {
            return false;
          }
        }
        return false;
      }
      tsIsUnambiguouslyStartOfFunctionType() {
        this.next();
        if (this.match(11) || this.match(21)) {
          return true;
        }
        if (this.tsSkipParameterStart()) {
          if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {
            return true;
          }
          if (this.match(11)) {
            this.next();
            if (this.match(19)) {
              return true;
            }
          }
        }
        return false;
      }
      tsParseTypeOrTypePredicateAnnotation(returnToken) {
        return this.tsInType(() => {
          const t3 = this.startNode();
          this.expect(returnToken);
          const node2 = this.startNode();
          const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
          if (asserts && this.match(78)) {
            let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
            if (thisTypePredicate.type === "TSThisType") {
              node2.parameterName = thisTypePredicate;
              node2.asserts = true;
              node2.typeAnnotation = null;
              thisTypePredicate = this.finishNode(node2, "TSTypePredicate");
            } else {
              this.resetStartLocationFromNode(thisTypePredicate, node2);
              thisTypePredicate.asserts = true;
            }
            t3.typeAnnotation = thisTypePredicate;
            return this.finishNode(t3, "TSTypeAnnotation");
          }
          const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
          if (!typePredicateVariable) {
            if (!asserts) {
              return this.tsParseTypeAnnotation(false, t3);
            }
            node2.parameterName = this.parseIdentifier();
            node2.asserts = asserts;
            node2.typeAnnotation = null;
            t3.typeAnnotation = this.finishNode(node2, "TSTypePredicate");
            return this.finishNode(t3, "TSTypeAnnotation");
          }
          const type = this.tsParseTypeAnnotation(false);
          node2.parameterName = typePredicateVariable;
          node2.typeAnnotation = type;
          node2.asserts = asserts;
          t3.typeAnnotation = this.finishNode(node2, "TSTypePredicate");
          return this.finishNode(t3, "TSTypeAnnotation");
        });
      }
      tsTryParseTypeOrTypePredicateAnnotation() {
        return this.match(14) ? this.tsParseTypeOrTypePredicateAnnotation(14) : void 0;
      }
      tsTryParseTypeAnnotation() {
        return this.match(14) ? this.tsParseTypeAnnotation() : void 0;
      }
      tsTryParseType() {
        return this.tsEatThenParseType(14);
      }
      tsParseTypePredicatePrefix() {
        const id = this.parseIdentifier();
        if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
          this.next();
          return id;
        }
      }
      tsParseTypePredicateAsserts() {
        if (this.state.type !== 107) {
          return false;
        }
        const containsEsc = this.state.containsEsc;
        this.next();
        if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
          return false;
        }
        if (containsEsc) {
          this.raise(Errors.InvalidEscapedReservedWord, {
            at: this.state.lastTokStartLoc,
            reservedWord: "asserts"
          });
        }
        return true;
      }
      tsParseTypeAnnotation(eatColon = true, t3 = this.startNode()) {
        this.tsInType(() => {
          if (eatColon)
            this.expect(14);
          t3.typeAnnotation = this.tsParseType();
        });
        return this.finishNode(t3, "TSTypeAnnotation");
      }
      tsParseType() {
        assert(this.state.inType);
        const type = this.tsParseNonConditionalType();
        if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
          return type;
        }
        const node2 = this.startNodeAtNode(type);
        node2.checkType = type;
        node2.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
        this.expect(17);
        node2.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
        this.expect(14);
        node2.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
        return this.finishNode(node2, "TSConditionalType");
      }
      isAbstractConstructorSignature() {
        return this.isContextual(122) && this.lookahead().type === 77;
      }
      tsParseNonConditionalType() {
        if (this.tsIsStartOfFunctionType()) {
          return this.tsParseFunctionOrConstructorType("TSFunctionType");
        }
        if (this.match(77)) {
          return this.tsParseFunctionOrConstructorType("TSConstructorType");
        } else if (this.isAbstractConstructorSignature()) {
          return this.tsParseFunctionOrConstructorType("TSConstructorType", true);
        }
        return this.tsParseUnionTypeOrHigher();
      }
      tsParseTypeAssertion() {
        if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
          this.raise(TSErrors.ReservedTypeAssertion, {
            at: this.state.startLoc
          });
        }
        const node2 = this.startNode();
        node2.typeAnnotation = this.tsInType(() => {
          this.next();
          return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
        });
        this.expect(48);
        node2.expression = this.parseMaybeUnary();
        return this.finishNode(node2, "TSTypeAssertion");
      }
      tsParseHeritageClause(token2) {
        const originalStartLoc = this.state.startLoc;
        const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
          const node2 = this.startNode();
          node2.expression = this.tsParseEntityName();
          if (this.match(47)) {
            node2.typeParameters = this.tsParseTypeArguments();
          }
          return this.finishNode(node2, "TSExpressionWithTypeArguments");
        });
        if (!delimitedList.length) {
          this.raise(TSErrors.EmptyHeritageClauseType, {
            at: originalStartLoc,
            token: token2
          });
        }
        return delimitedList;
      }
      tsParseInterfaceDeclaration(node2, properties = {}) {
        if (this.hasFollowingLineBreak())
          return null;
        this.expectContextual(127);
        if (properties.declare)
          node2.declare = true;
        if (tokenIsIdentifier(this.state.type)) {
          node2.id = this.parseIdentifier();
          this.checkIdentifier(node2.id, BIND_TS_INTERFACE);
        } else {
          node2.id = null;
          this.raise(TSErrors.MissingInterfaceName, {
            at: this.state.startLoc
          });
        }
        node2.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
        if (this.eat(81)) {
          node2.extends = this.tsParseHeritageClause("extends");
        }
        const body = this.startNode();
        body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
        node2.body = this.finishNode(body, "TSInterfaceBody");
        return this.finishNode(node2, "TSInterfaceDeclaration");
      }
      tsParseTypeAliasDeclaration(node2) {
        node2.id = this.parseIdentifier();
        this.checkIdentifier(node2.id, BIND_TS_TYPE);
        node2.typeAnnotation = this.tsInType(() => {
          node2.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
          this.expect(29);
          if (this.isContextual(112) && this.lookahead().type !== 16) {
            const node3 = this.startNode();
            this.next();
            return this.finishNode(node3, "TSIntrinsicKeyword");
          }
          return this.tsParseType();
        });
        this.semicolon();
        return this.finishNode(node2, "TSTypeAliasDeclaration");
      }
      tsInNoContext(cb) {
        const oldContext = this.state.context;
        this.state.context = [oldContext[0]];
        try {
          return cb();
        } finally {
          this.state.context = oldContext;
        }
      }
      tsInType(cb) {
        const oldInType = this.state.inType;
        this.state.inType = true;
        try {
          return cb();
        } finally {
          this.state.inType = oldInType;
        }
      }
      tsInDisallowConditionalTypesContext(cb) {
        const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
        this.state.inDisallowConditionalTypesContext = true;
        try {
          return cb();
        } finally {
          this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
        }
      }
      tsInAllowConditionalTypesContext(cb) {
        const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
        this.state.inDisallowConditionalTypesContext = false;
        try {
          return cb();
        } finally {
          this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
        }
      }
      tsEatThenParseType(token2) {
        return !this.match(token2) ? void 0 : this.tsNextThenParseType();
      }
      tsExpectThenParseType(token2) {
        return this.tsDoThenParseType(() => this.expect(token2));
      }
      tsNextThenParseType() {
        return this.tsDoThenParseType(() => this.next());
      }
      tsDoThenParseType(cb) {
        return this.tsInType(() => {
          cb();
          return this.tsParseType();
        });
      }
      tsParseEnumMember() {
        const node2 = this.startNode();
        node2.id = this.match(131) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
        if (this.eat(29)) {
          node2.initializer = super.parseMaybeAssignAllowIn();
        }
        return this.finishNode(node2, "TSEnumMember");
      }
      tsParseEnumDeclaration(node2, properties = {}) {
        if (properties.const)
          node2.const = true;
        if (properties.declare)
          node2.declare = true;
        this.expectContextual(124);
        node2.id = this.parseIdentifier();
        this.checkIdentifier(node2.id, node2.const ? BIND_TS_CONST_ENUM : BIND_TS_ENUM);
        this.expect(5);
        node2.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
        this.expect(8);
        return this.finishNode(node2, "TSEnumDeclaration");
      }
      tsParseModuleBlock() {
        const node2 = this.startNode();
        this.scope.enter(SCOPE_OTHER);
        this.expect(5);
        super.parseBlockOrModuleBlockBody(node2.body = [], void 0, true, 8);
        this.scope.exit();
        return this.finishNode(node2, "TSModuleBlock");
      }
      tsParseModuleOrNamespaceDeclaration(node2, nested = false) {
        node2.id = this.parseIdentifier();
        if (!nested) {
          this.checkIdentifier(node2.id, BIND_TS_NAMESPACE);
        }
        if (this.eat(16)) {
          const inner = this.startNode();
          this.tsParseModuleOrNamespaceDeclaration(inner, true);
          node2.body = inner;
        } else {
          this.scope.enter(SCOPE_TS_MODULE);
          this.prodParam.enter(PARAM);
          node2.body = this.tsParseModuleBlock();
          this.prodParam.exit();
          this.scope.exit();
        }
        return this.finishNode(node2, "TSModuleDeclaration");
      }
      tsParseAmbientExternalModuleDeclaration(node2) {
        if (this.isContextual(110)) {
          node2.global = true;
          node2.id = this.parseIdentifier();
        } else if (this.match(131)) {
          node2.id = super.parseStringLiteral(this.state.value);
        } else {
          this.unexpected();
        }
        if (this.match(5)) {
          this.scope.enter(SCOPE_TS_MODULE);
          this.prodParam.enter(PARAM);
          node2.body = this.tsParseModuleBlock();
          this.prodParam.exit();
          this.scope.exit();
        } else {
          this.semicolon();
        }
        return this.finishNode(node2, "TSModuleDeclaration");
      }
      tsParseImportEqualsDeclaration(node2, isExport) {
        node2.isExport = isExport || false;
        node2.id = this.parseIdentifier();
        this.checkIdentifier(node2.id, BIND_FLAGS_TS_IMPORT);
        this.expect(29);
        const moduleReference = this.tsParseModuleReference();
        if (node2.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
          this.raise(TSErrors.ImportAliasHasImportType, {
            at: moduleReference
          });
        }
        node2.moduleReference = moduleReference;
        this.semicolon();
        return this.finishNode(node2, "TSImportEqualsDeclaration");
      }
      tsIsExternalModuleReference() {
        return this.isContextual(117) && this.lookaheadCharCode() === 40;
      }
      tsParseModuleReference() {
        return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
      }
      tsParseExternalModuleReference() {
        const node2 = this.startNode();
        this.expectContextual(117);
        this.expect(10);
        if (!this.match(131)) {
          this.unexpected();
        }
        node2.expression = super.parseExprAtom();
        this.expect(11);
        return this.finishNode(node2, "TSExternalModuleReference");
      }
      tsLookAhead(f) {
        const state = this.state.clone();
        const res = f();
        this.state = state;
        return res;
      }
      tsTryParseAndCatch(f) {
        const result = this.tryParse((abort) => f() || abort());
        if (result.aborted || !result.node)
          return void 0;
        if (result.error)
          this.state = result.failState;
        return result.node;
      }
      tsTryParse(f) {
        const state = this.state.clone();
        const result = f();
        if (result !== void 0 && result !== false) {
          return result;
        } else {
          this.state = state;
          return void 0;
        }
      }
      tsTryParseDeclare(nany) {
        if (this.isLineTerminator()) {
          return;
        }
        let starttype = this.state.type;
        let kind;
        if (this.isContextual(99)) {
          starttype = 74;
          kind = "let";
        }
        return this.tsInAmbientContext(() => {
          if (starttype === 68) {
            nany.declare = true;
            return super.parseFunctionStatement(nany, false, false);
          }
          if (starttype === 80) {
            nany.declare = true;
            return this.parseClass(nany, true, false);
          }
          if (starttype === 124) {
            return this.tsParseEnumDeclaration(nany, {
              declare: true
            });
          }
          if (starttype === 110) {
            return this.tsParseAmbientExternalModuleDeclaration(nany);
          }
          if (starttype === 75 || starttype === 74) {
            if (!this.match(75) || !this.isLookaheadContextual("enum")) {
              nany.declare = true;
              return this.parseVarStatement(nany, kind || this.state.value, true);
            }
            this.expect(75);
            return this.tsParseEnumDeclaration(nany, {
              const: true,
              declare: true
            });
          }
          if (starttype === 127) {
            const result = this.tsParseInterfaceDeclaration(nany, {
              declare: true
            });
            if (result)
              return result;
          }
          if (tokenIsIdentifier(starttype)) {
            return this.tsParseDeclaration(nany, this.state.value, true, null);
          }
        });
      }
      tsTryParseExportDeclaration() {
        return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
      }
      tsParseExpressionStatement(node2, expr, decorators) {
        switch (expr.name) {
          case "declare": {
            const declaration = this.tsTryParseDeclare(node2);
            if (declaration) {
              declaration.declare = true;
              return declaration;
            }
            break;
          }
          case "global":
            if (this.match(5)) {
              this.scope.enter(SCOPE_TS_MODULE);
              this.prodParam.enter(PARAM);
              const mod = node2;
              mod.global = true;
              mod.id = expr;
              mod.body = this.tsParseModuleBlock();
              this.scope.exit();
              this.prodParam.exit();
              return this.finishNode(mod, "TSModuleDeclaration");
            }
            break;
          default:
            return this.tsParseDeclaration(node2, expr.name, false, decorators);
        }
      }
      tsParseDeclaration(node2, value2, next, decorators) {
        switch (value2) {
          case "abstract":
            if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
              return this.tsParseAbstractDeclaration(node2, decorators);
            }
            break;
          case "module":
            if (this.tsCheckLineTerminator(next)) {
              if (this.match(131)) {
                return this.tsParseAmbientExternalModuleDeclaration(node2);
              } else if (tokenIsIdentifier(this.state.type)) {
                return this.tsParseModuleOrNamespaceDeclaration(node2);
              }
            }
            break;
          case "namespace":
            if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
              return this.tsParseModuleOrNamespaceDeclaration(node2);
            }
            break;
          case "type":
            if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
              return this.tsParseTypeAliasDeclaration(node2);
            }
            break;
        }
      }
      tsCheckLineTerminator(next) {
        if (next) {
          if (this.hasFollowingLineBreak())
            return false;
          this.next();
          return true;
        }
        return !this.isLineTerminator();
      }
      tsTryParseGenericAsyncArrowFunction(startLoc) {
        if (!this.match(47)) {
          return void 0;
        }
        const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
        this.state.maybeInArrowParameters = true;
        const res = this.tsTryParseAndCatch(() => {
          const node2 = this.startNodeAt(startLoc);
          node2.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
          super.parseFunctionParams(node2);
          node2.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
          this.expect(19);
          return node2;
        });
        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
        if (!res) {
          return void 0;
        }
        return super.parseArrowExpression(res, null, true);
      }
      tsParseTypeArgumentsInExpression() {
        if (this.reScan_lt() !== 47) {
          return void 0;
        }
        return this.tsParseTypeArguments();
      }
      tsParseTypeArguments() {
        const node2 = this.startNode();
        node2.params = this.tsInType(() => this.tsInNoContext(() => {
          this.expect(47);
          return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
        }));
        if (node2.params.length === 0) {
          this.raise(TSErrors.EmptyTypeArguments, {
            at: node2
          });
        }
        this.expect(48);
        return this.finishNode(node2, "TSTypeParameterInstantiation");
      }
      tsIsDeclarationStart() {
        return tokenIsTSDeclarationStart(this.state.type);
      }
      isExportDefaultSpecifier() {
        if (this.tsIsDeclarationStart())
          return false;
        return super.isExportDefaultSpecifier();
      }
      parseAssignableListItem(flags, decorators) {
        const startLoc = this.state.startLoc;
        const modified = {};
        this.tsParseModifiers({
          allowedModifiers: ["public", "private", "protected", "override", "readonly"]
        }, modified);
        const accessibility = modified.accessibility;
        const override = modified.override;
        const readonly = modified.readonly;
        if (!(flags & 4) && (accessibility || readonly || override)) {
          this.raise(TSErrors.UnexpectedParameterModifier, {
            at: startLoc
          });
        }
        const left = this.parseMaybeDefault();
        this.parseAssignableListItemTypes(left, flags);
        const elt = this.parseMaybeDefault(left.loc.start, left);
        if (accessibility || readonly || override) {
          const pp3 = this.startNodeAt(startLoc);
          if (decorators.length) {
            pp3.decorators = decorators;
          }
          if (accessibility)
            pp3.accessibility = accessibility;
          if (readonly)
            pp3.readonly = readonly;
          if (override)
            pp3.override = override;
          if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
            this.raise(TSErrors.UnsupportedParameterPropertyKind, {
              at: pp3
            });
          }
          pp3.parameter = elt;
          return this.finishNode(pp3, "TSParameterProperty");
        }
        if (decorators.length) {
          left.decorators = decorators;
        }
        return elt;
      }
      isSimpleParameter(node2) {
        return node2.type === "TSParameterProperty" && super.isSimpleParameter(node2.parameter) || super.isSimpleParameter(node2);
      }
      tsDisallowOptionalPattern(node2) {
        for (const param of node2.params) {
          if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
            this.raise(TSErrors.PatternIsOptional, {
              at: param
            });
          }
        }
      }
      setArrowFunctionParameters(node2, params, trailingCommaLoc) {
        super.setArrowFunctionParameters(node2, params, trailingCommaLoc);
        this.tsDisallowOptionalPattern(node2);
      }
      parseFunctionBodyAndFinish(node2, type, isMethod = false) {
        if (this.match(14)) {
          node2.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
        }
        const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : void 0;
        if (bodilessType && !this.match(5) && this.isLineTerminator()) {
          return this.finishNode(node2, bodilessType);
        }
        if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
          this.raise(TSErrors.DeclareFunctionHasImplementation, {
            at: node2
          });
          if (node2.declare) {
            return super.parseFunctionBodyAndFinish(node2, bodilessType, isMethod);
          }
        }
        this.tsDisallowOptionalPattern(node2);
        return super.parseFunctionBodyAndFinish(node2, type, isMethod);
      }
      registerFunctionStatementId(node2) {
        if (!node2.body && node2.id) {
          this.checkIdentifier(node2.id, BIND_TS_AMBIENT);
        } else {
          super.registerFunctionStatementId(node2);
        }
      }
      tsCheckForInvalidTypeCasts(items) {
        items.forEach((node2) => {
          if ((node2 == null ? void 0 : node2.type) === "TSTypeCastExpression") {
            this.raise(TSErrors.UnexpectedTypeAnnotation, {
              at: node2.typeAnnotation
            });
          }
        });
      }
      toReferencedList(exprList, isInParens) {
        this.tsCheckForInvalidTypeCasts(exprList);
        return exprList;
      }
      parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
        const node2 = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
        if (node2.type === "ArrayExpression") {
          this.tsCheckForInvalidTypeCasts(node2.elements);
        }
        return node2;
      }
      parseSubscript(base2, startLoc, noCalls, state) {
        if (!this.hasPrecedingLineBreak() && this.match(35)) {
          this.state.canStartJSXElement = false;
          this.next();
          const nonNullExpression = this.startNodeAt(startLoc);
          nonNullExpression.expression = base2;
          return this.finishNode(nonNullExpression, "TSNonNullExpression");
        }
        let isOptionalCall = false;
        if (this.match(18) && this.lookaheadCharCode() === 60) {
          if (noCalls) {
            state.stop = true;
            return base2;
          }
          state.optionalChainMember = isOptionalCall = true;
          this.next();
        }
        if (this.match(47) || this.match(51)) {
          let missingParenErrorLoc;
          const result = this.tsTryParseAndCatch(() => {
            if (!noCalls && this.atPossibleAsyncArrow(base2)) {
              const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
              if (asyncArrowFn) {
                return asyncArrowFn;
              }
            }
            const typeArguments = this.tsParseTypeArgumentsInExpression();
            if (!typeArguments)
              return;
            if (isOptionalCall && !this.match(10)) {
              missingParenErrorLoc = this.state.curPosition();
              return;
            }
            if (tokenIsTemplate(this.state.type)) {
              const result2 = super.parseTaggedTemplateExpression(base2, startLoc, state);
              result2.typeParameters = typeArguments;
              return result2;
            }
            if (!noCalls && this.eat(10)) {
              const node3 = this.startNodeAt(startLoc);
              node3.callee = base2;
              node3.arguments = this.parseCallExpressionArguments(11, false);
              this.tsCheckForInvalidTypeCasts(node3.arguments);
              node3.typeParameters = typeArguments;
              if (state.optionalChainMember) {
                node3.optional = isOptionalCall;
              }
              return this.finishCallExpression(node3, state.optionalChainMember);
            }
            const tokenType = this.state.type;
            if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
              return;
            }
            const node2 = this.startNodeAt(startLoc);
            node2.expression = base2;
            node2.typeParameters = typeArguments;
            return this.finishNode(node2, "TSInstantiationExpression");
          });
          if (missingParenErrorLoc) {
            this.unexpected(missingParenErrorLoc, 10);
          }
          if (result) {
            if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
              this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
                at: this.state.startLoc
              });
            }
            return result;
          }
        }
        return super.parseSubscript(base2, startLoc, noCalls, state);
      }
      parseNewCallee(node2) {
        var _callee$extra;
        super.parseNewCallee(node2);
        const {
          callee
        } = node2;
        if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
          node2.typeParameters = callee.typeParameters;
          node2.callee = callee.expression;
        }
      }
      parseExprOp(left, leftStartLoc, minPrec) {
        let isSatisfies;
        if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(118)))) {
          const node2 = this.startNodeAt(leftStartLoc);
          node2.expression = left;
          node2.typeAnnotation = this.tsInType(() => {
            this.next();
            if (this.match(75)) {
              if (isSatisfies) {
                this.raise(Errors.UnexpectedKeyword, {
                  at: this.state.startLoc,
                  keyword: "const"
                });
              }
              return this.tsParseTypeReference();
            }
            return this.tsParseType();
          });
          this.finishNode(node2, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
          this.reScan_lt_gt();
          return this.parseExprOp(node2, leftStartLoc, minPrec);
        }
        return super.parseExprOp(left, leftStartLoc, minPrec);
      }
      checkReservedWord(word, startLoc, checkKeywords, isBinding) {
        if (!this.state.isAmbientContext) {
          super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
        }
      }
      checkImportReflection(node2) {
        super.checkImportReflection(node2);
        if (node2.module && node2.importKind !== "value") {
          this.raise(TSErrors.ImportReflectionHasImportType, {
            at: node2.specifiers[0].loc.start
          });
        }
      }
      checkDuplicateExports() {
      }
      parseImport(node2) {
        node2.importKind = "value";
        if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) {
          let ahead = this.lookahead();
          if (this.isContextual(128) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) {
            node2.importKind = "type";
            this.next();
            ahead = this.lookahead();
          }
          if (tokenIsIdentifier(this.state.type) && ahead.type === 29) {
            return this.tsParseImportEqualsDeclaration(node2);
          }
        }
        const importNode = super.parseImport(node2);
        if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
          this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
            at: importNode
          });
        }
        return importNode;
      }
      parseExport(node2, decorators) {
        if (this.match(83)) {
          this.next();
          if (this.isContextual(128) && this.lookaheadCharCode() !== 61) {
            node2.importKind = "type";
            this.next();
          } else {
            node2.importKind = "value";
          }
          return this.tsParseImportEqualsDeclaration(node2, true);
        } else if (this.eat(29)) {
          const assign = node2;
          assign.expression = super.parseExpression();
          this.semicolon();
          return this.finishNode(assign, "TSExportAssignment");
        } else if (this.eatContextual(93)) {
          const decl = node2;
          this.expectContextual(126);
          decl.id = this.parseIdentifier();
          this.semicolon();
          return this.finishNode(decl, "TSNamespaceExportDeclaration");
        } else {
          node2.exportKind = "value";
          if (this.isContextual(128)) {
            const ch = this.lookaheadCharCode();
            if (ch === 123 || ch === 42) {
              this.next();
              node2.exportKind = "type";
            }
          }
          return super.parseExport(node2, decorators);
        }
      }
      isAbstractClass() {
        return this.isContextual(122) && this.lookahead().type === 80;
      }
      parseExportDefaultExpression() {
        if (this.isAbstractClass()) {
          const cls = this.startNode();
          this.next();
          cls.abstract = true;
          return this.parseClass(cls, true, true);
        }
        if (this.match(127)) {
          const result = this.tsParseInterfaceDeclaration(this.startNode());
          if (result)
            return result;
        }
        return super.parseExportDefaultExpression();
      }
      parseVarStatement(node2, kind, allowMissingInitializer = false) {
        const {
          isAmbientContext
        } = this.state;
        const declaration = super.parseVarStatement(node2, kind, allowMissingInitializer || isAmbientContext);
        if (!isAmbientContext)
          return declaration;
        for (const {
          id,
          init
        } of declaration.declarations) {
          if (!init)
            continue;
          if (kind !== "const" || !!id.typeAnnotation) {
            this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
              at: init
            });
          } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
            this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
              at: init
            });
          }
        }
        return declaration;
      }
      parseStatementContent(flags, decorators) {
        if (this.match(75) && this.isLookaheadContextual("enum")) {
          const node2 = this.startNode();
          this.expect(75);
          return this.tsParseEnumDeclaration(node2, {
            const: true
          });
        }
        if (this.isContextual(124)) {
          return this.tsParseEnumDeclaration(this.startNode());
        }
        if (this.isContextual(127)) {
          const result = this.tsParseInterfaceDeclaration(this.startNode());
          if (result)
            return result;
        }
        return super.parseStatementContent(flags, decorators);
      }
      parseAccessModifier() {
        return this.tsParseModifier(["public", "protected", "private"]);
      }
      tsHasSomeModifiers(member, modifiers) {
        return modifiers.some((modifier) => {
          if (tsIsAccessModifier(modifier)) {
            return member.accessibility === modifier;
          }
          return !!member[modifier];
        });
      }
      tsIsStartOfStaticBlocks() {
        return this.isContextual(104) && this.lookaheadCharCode() === 123;
      }
      parseClassMember(classBody, member, state) {
        const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
        this.tsParseModifiers({
          allowedModifiers: modifiers,
          disallowedModifiers: ["in", "out"],
          stopOnStartOfClassStaticBlock: true,
          errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
        }, member);
        const callParseClassMemberWithIsStatic = () => {
          if (this.tsIsStartOfStaticBlocks()) {
            this.next();
            this.next();
            if (this.tsHasSomeModifiers(member, modifiers)) {
              this.raise(TSErrors.StaticBlockCannotHaveModifier, {
                at: this.state.curPosition()
              });
            }
            super.parseClassStaticBlock(classBody, member);
          } else {
            this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
          }
        };
        if (member.declare) {
          this.tsInAmbientContext(callParseClassMemberWithIsStatic);
        } else {
          callParseClassMemberWithIsStatic();
        }
      }
      parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
        const idx = this.tsTryParseIndexSignature(member);
        if (idx) {
          classBody.body.push(idx);
          if (member.abstract) {
            this.raise(TSErrors.IndexSignatureHasAbstract, {
              at: member
            });
          }
          if (member.accessibility) {
            this.raise(TSErrors.IndexSignatureHasAccessibility, {
              at: member,
              modifier: member.accessibility
            });
          }
          if (member.declare) {
            this.raise(TSErrors.IndexSignatureHasDeclare, {
              at: member
            });
          }
          if (member.override) {
            this.raise(TSErrors.IndexSignatureHasOverride, {
              at: member
            });
          }
          return;
        }
        if (!this.state.inAbstractClass && member.abstract) {
          this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
            at: member
          });
        }
        if (member.override) {
          if (!state.hadSuperClass) {
            this.raise(TSErrors.OverrideNotInSubClass, {
              at: member
            });
          }
        }
        super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
      }
      parsePostMemberNameModifiers(methodOrProp) {
        const optional = this.eat(17);
        if (optional)
          methodOrProp.optional = true;
        if (methodOrProp.readonly && this.match(10)) {
          this.raise(TSErrors.ClassMethodHasReadonly, {
            at: methodOrProp
          });
        }
        if (methodOrProp.declare && this.match(10)) {
          this.raise(TSErrors.ClassMethodHasDeclare, {
            at: methodOrProp
          });
        }
      }
      parseExpressionStatement(node2, expr, decorators) {
        const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node2, expr, decorators) : void 0;
        return decl || super.parseExpressionStatement(node2, expr, decorators);
      }
      shouldParseExportDeclaration() {
        if (this.tsIsDeclarationStart())
          return true;
        return super.shouldParseExportDeclaration();
      }
      parseConditional(expr, startLoc, refExpressionErrors) {
        if (!this.state.maybeInArrowParameters || !this.match(17)) {
          return super.parseConditional(expr, startLoc, refExpressionErrors);
        }
        const result = this.tryParse(() => super.parseConditional(expr, startLoc));
        if (!result.node) {
          if (result.error) {
            super.setOptionalParametersError(refExpressionErrors, result.error);
          }
          return expr;
        }
        if (result.error)
          this.state = result.failState;
        return result.node;
      }
      parseParenItem(node2, startLoc) {
        node2 = super.parseParenItem(node2, startLoc);
        if (this.eat(17)) {
          node2.optional = true;
          this.resetEndLocation(node2);
        }
        if (this.match(14)) {
          const typeCastNode = this.startNodeAt(startLoc);
          typeCastNode.expression = node2;
          typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
          return this.finishNode(typeCastNode, "TSTypeCastExpression");
        }
        return node2;
      }
      parseExportDeclaration(node2) {
        if (!this.state.isAmbientContext && this.isContextual(123)) {
          return this.tsInAmbientContext(() => this.parseExportDeclaration(node2));
        }
        const startLoc = this.state.startLoc;
        const isDeclare = this.eatContextual(123);
        if (isDeclare && (this.isContextual(123) || !this.shouldParseExportDeclaration())) {
          throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
            at: this.state.startLoc
          });
        }
        const isIdentifier3 = tokenIsIdentifier(this.state.type);
        const declaration = isIdentifier3 && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node2);
        if (!declaration)
          return null;
        if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
          node2.exportKind = "type";
        }
        if (isDeclare) {
          this.resetStartLocation(declaration, startLoc);
          declaration.declare = true;
        }
        return declaration;
      }
      parseClassId(node2, isStatement, optionalId, bindingType) {
        if ((!isStatement || optionalId) && this.isContextual(111)) {
          return;
        }
        super.parseClassId(node2, isStatement, optionalId, node2.declare ? BIND_TS_AMBIENT : BIND_CLASS);
        const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
        if (typeParameters)
          node2.typeParameters = typeParameters;
      }
      parseClassPropertyAnnotation(node2) {
        if (!node2.optional) {
          if (this.eat(35)) {
            node2.definite = true;
          } else if (this.eat(17)) {
            node2.optional = true;
          }
        }
        const type = this.tsTryParseTypeAnnotation();
        if (type)
          node2.typeAnnotation = type;
      }
      parseClassProperty(node2) {
        this.parseClassPropertyAnnotation(node2);
        if (this.state.isAmbientContext && !(node2.readonly && !node2.typeAnnotation) && this.match(29)) {
          this.raise(TSErrors.DeclareClassFieldHasInitializer, {
            at: this.state.startLoc
          });
        }
        if (node2.abstract && this.match(29)) {
          const {
            key: key2
          } = node2;
          this.raise(TSErrors.AbstractPropertyHasInitializer, {
            at: this.state.startLoc,
            propertyName: key2.type === "Identifier" && !node2.computed ? key2.name : `[${this.input.slice(key2.start, key2.end)}]`
          });
        }
        return super.parseClassProperty(node2);
      }
      parseClassPrivateProperty(node2) {
        if (node2.abstract) {
          this.raise(TSErrors.PrivateElementHasAbstract, {
            at: node2
          });
        }
        if (node2.accessibility) {
          this.raise(TSErrors.PrivateElementHasAccessibility, {
            at: node2,
            modifier: node2.accessibility
          });
        }
        this.parseClassPropertyAnnotation(node2);
        return super.parseClassPrivateProperty(node2);
      }
      parseClassAccessorProperty(node2) {
        this.parseClassPropertyAnnotation(node2);
        if (node2.optional) {
          this.raise(TSErrors.AccessorCannotBeOptional, {
            at: node2
          });
        }
        return super.parseClassAccessorProperty(node2);
      }
      pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
        const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters && isConstructor) {
          this.raise(TSErrors.ConstructorHasTypeParameters, {
            at: typeParameters
          });
        }
        const {
          declare = false,
          kind
        } = method;
        if (declare && (kind === "get" || kind === "set")) {
          this.raise(TSErrors.DeclareAccessor, {
            at: method,
            kind
          });
        }
        if (typeParameters)
          method.typeParameters = typeParameters;
        super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
      }
      pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
        const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters)
          method.typeParameters = typeParameters;
        super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
      }
      declareClassPrivateMethodInScope(node2, kind) {
        if (node2.type === "TSDeclareMethod")
          return;
        if (node2.type === "MethodDefinition" && !node2.value.body)
          return;
        super.declareClassPrivateMethodInScope(node2, kind);
      }
      parseClassSuper(node2) {
        super.parseClassSuper(node2);
        if (node2.superClass && (this.match(47) || this.match(51))) {
          node2.superTypeParameters = this.tsParseTypeArgumentsInExpression();
        }
        if (this.eatContextual(111)) {
          node2.implements = this.tsParseHeritageClause("implements");
        }
      }
      parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
        const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters)
          prop.typeParameters = typeParameters;
        return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
      }
      parseFunctionParams(node2, isConstructor) {
        const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters)
          node2.typeParameters = typeParameters;
        super.parseFunctionParams(node2, isConstructor);
      }
      parseVarId(decl, kind) {
        super.parseVarId(decl, kind);
        if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
          decl.definite = true;
        }
        const type = this.tsTryParseTypeAnnotation();
        if (type) {
          decl.id.typeAnnotation = type;
          this.resetEndLocation(decl.id);
        }
      }
      parseAsyncArrowFromCallExpression(node2, call) {
        if (this.match(14)) {
          node2.returnType = this.tsParseTypeAnnotation();
        }
        return super.parseAsyncArrowFromCallExpression(node2, call);
      }
      parseMaybeAssign(refExpressionErrors, afterLeftParse) {
        var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
        let state;
        let jsx3;
        let typeCast;
        if (this.hasPlugin("jsx") && (this.match(140) || this.match(47))) {
          state = this.state.clone();
          jsx3 = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
          if (!jsx3.error)
            return jsx3.node;
          const {
            context
          } = this.state;
          const currentContext = context[context.length - 1];
          if (currentContext === types3.j_oTag || currentContext === types3.j_expr) {
            context.pop();
          }
        }
        if (!((_jsx = jsx3) != null && _jsx.error) && !this.match(47)) {
          return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
        }
        if (!state || state === this.state)
          state = this.state.clone();
        let typeParameters;
        const arrow = this.tryParse((abort) => {
          var _expr$extra, _typeParameters;
          typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
          const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
          if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
            abort();
          }
          if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {
            this.resetStartLocationFromNode(expr, typeParameters);
          }
          expr.typeParameters = typeParameters;
          return expr;
        }, state);
        if (!arrow.error && !arrow.aborted) {
          if (typeParameters)
            this.reportReservedArrowTypeParam(typeParameters);
          return arrow.node;
        }
        if (!jsx3) {
          assert(!this.hasPlugin("jsx"));
          typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
          if (!typeCast.error)
            return typeCast.node;
        }
        if ((_jsx2 = jsx3) != null && _jsx2.node) {
          this.state = jsx3.failState;
          return jsx3.node;
        }
        if (arrow.node) {
          this.state = arrow.failState;
          if (typeParameters)
            this.reportReservedArrowTypeParam(typeParameters);
          return arrow.node;
        }
        if ((_typeCast = typeCast) != null && _typeCast.node) {
          this.state = typeCast.failState;
          return typeCast.node;
        }
        if ((_jsx3 = jsx3) != null && _jsx3.thrown)
          throw jsx3.error;
        if (arrow.thrown)
          throw arrow.error;
        if ((_typeCast2 = typeCast) != null && _typeCast2.thrown)
          throw typeCast.error;
        throw ((_jsx4 = jsx3) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error);
      }
      reportReservedArrowTypeParam(node2) {
        var _node$extra;
        if (node2.params.length === 1 && !node2.params[0].constraint && !((_node$extra = node2.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
          this.raise(TSErrors.ReservedArrowTypeParam, {
            at: node2
          });
        }
      }
      parseMaybeUnary(refExpressionErrors, sawUnary) {
        if (!this.hasPlugin("jsx") && this.match(47)) {
          return this.tsParseTypeAssertion();
        } else {
          return super.parseMaybeUnary(refExpressionErrors, sawUnary);
        }
      }
      parseArrow(node2) {
        if (this.match(14)) {
          const result = this.tryParse((abort) => {
            const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
            if (this.canInsertSemicolon() || !this.match(19))
              abort();
            return returnType;
          });
          if (result.aborted)
            return;
          if (!result.thrown) {
            if (result.error)
              this.state = result.failState;
            node2.returnType = result.node;
          }
        }
        return super.parseArrow(node2);
      }
      parseAssignableListItemTypes(param, flags) {
        if (!(flags & 2))
          return param;
        if (this.eat(17)) {
          param.optional = true;
        }
        const type = this.tsTryParseTypeAnnotation();
        if (type)
          param.typeAnnotation = type;
        this.resetEndLocation(param);
        return param;
      }
      isAssignable(node2, isBinding) {
        switch (node2.type) {
          case "TSTypeCastExpression":
            return this.isAssignable(node2.expression, isBinding);
          case "TSParameterProperty":
            return true;
          default:
            return super.isAssignable(node2, isBinding);
        }
      }
      toAssignable(node2, isLHS = false) {
        switch (node2.type) {
          case "ParenthesizedExpression":
            this.toAssignableParenthesizedExpression(node2, isLHS);
            break;
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSNonNullExpression":
          case "TSTypeAssertion":
            if (isLHS) {
              this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
                at: node2
              });
            } else {
              this.raise(TSErrors.UnexpectedTypeCastInParameter, {
                at: node2
              });
            }
            this.toAssignable(node2.expression, isLHS);
            break;
          case "AssignmentExpression":
            if (!isLHS && node2.left.type === "TSTypeCastExpression") {
              node2.left = this.typeCastToParameter(node2.left);
            }
          default:
            super.toAssignable(node2, isLHS);
        }
      }
      toAssignableParenthesizedExpression(node2, isLHS) {
        switch (node2.expression.type) {
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSNonNullExpression":
          case "TSTypeAssertion":
          case "ParenthesizedExpression":
            this.toAssignable(node2.expression, isLHS);
            break;
          default:
            super.toAssignable(node2, isLHS);
        }
      }
      checkToRestConversion(node2, allowPattern) {
        switch (node2.type) {
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSTypeAssertion":
          case "TSNonNullExpression":
            this.checkToRestConversion(node2.expression, false);
            break;
          default:
            super.checkToRestConversion(node2, allowPattern);
        }
      }
      isValidLVal(type, isUnparenthesizedInAssign, binding) {
        return getOwn({
          TSTypeCastExpression: true,
          TSParameterProperty: "parameter",
          TSNonNullExpression: "expression",
          TSAsExpression: (binding !== BIND_NONE3 || !isUnparenthesizedInAssign) && ["expression", true],
          TSSatisfiesExpression: (binding !== BIND_NONE3 || !isUnparenthesizedInAssign) && ["expression", true],
          TSTypeAssertion: (binding !== BIND_NONE3 || !isUnparenthesizedInAssign) && ["expression", true]
        }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
      }
      parseBindingAtom() {
        switch (this.state.type) {
          case 78:
            return this.parseIdentifier(true);
          default:
            return super.parseBindingAtom();
        }
      }
      parseMaybeDecoratorArguments(expr) {
        if (this.match(47) || this.match(51)) {
          const typeArguments = this.tsParseTypeArgumentsInExpression();
          if (this.match(10)) {
            const call = super.parseMaybeDecoratorArguments(expr);
            call.typeParameters = typeArguments;
            return call;
          }
          this.unexpected(null, 10);
        }
        return super.parseMaybeDecoratorArguments(expr);
      }
      checkCommaAfterRest(close) {
        if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
          this.next();
          return false;
        } else {
          return super.checkCommaAfterRest(close);
        }
      }
      isClassMethod() {
        return this.match(47) || super.isClassMethod();
      }
      isClassProperty() {
        return this.match(35) || this.match(14) || super.isClassProperty();
      }
      parseMaybeDefault(startLoc, left) {
        const node2 = super.parseMaybeDefault(startLoc, left);
        if (node2.type === "AssignmentPattern" && node2.typeAnnotation && node2.right.start < node2.typeAnnotation.start) {
          this.raise(TSErrors.TypeAnnotationAfterAssign, {
            at: node2.typeAnnotation
          });
        }
        return node2;
      }
      getTokenFromCode(code2) {
        if (this.state.inType) {
          if (code2 === 62) {
            this.finishOp(48, 1);
            return;
          }
          if (code2 === 60) {
            this.finishOp(47, 1);
            return;
          }
        }
        super.getTokenFromCode(code2);
      }
      reScan_lt_gt() {
        const {
          type
        } = this.state;
        if (type === 47) {
          this.state.pos -= 1;
          this.readToken_lt();
        } else if (type === 48) {
          this.state.pos -= 1;
          this.readToken_gt();
        }
      }
      reScan_lt() {
        const {
          type
        } = this.state;
        if (type === 51) {
          this.state.pos -= 2;
          this.finishOp(47, 1);
          return 47;
        }
        return type;
      }
      toAssignableList(exprList, trailingCommaLoc, isLHS) {
        for (let i = 0; i < exprList.length; i++) {
          const expr = exprList[i];
          if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
            exprList[i] = this.typeCastToParameter(expr);
          }
        }
        super.toAssignableList(exprList, trailingCommaLoc, isLHS);
      }
      typeCastToParameter(node2) {
        node2.expression.typeAnnotation = node2.typeAnnotation;
        this.resetEndLocation(node2.expression, node2.typeAnnotation.loc.end);
        return node2.expression;
      }
      shouldParseArrow(params) {
        if (this.match(14)) {
          return params.every((expr) => this.isAssignable(expr, true));
        }
        return super.shouldParseArrow(params);
      }
      shouldParseAsyncArrow() {
        return this.match(14) || super.shouldParseAsyncArrow();
      }
      canHaveLeadingDecorator() {
        return super.canHaveLeadingDecorator() || this.isAbstractClass();
      }
      jsxParseOpeningElementAfterName(node2) {
        if (this.match(47) || this.match(51)) {
          const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
          if (typeArguments)
            node2.typeParameters = typeArguments;
        }
        return super.jsxParseOpeningElementAfterName(node2);
      }
      getGetterSetterExpectedParamCount(method) {
        const baseCount = super.getGetterSetterExpectedParamCount(method);
        const params = this.getObjectOrClassMethodParams(method);
        const firstParam = params[0];
        const hasContextParam = firstParam && this.isThisParam(firstParam);
        return hasContextParam ? baseCount + 1 : baseCount;
      }
      parseCatchClauseParam() {
        const param = super.parseCatchClauseParam();
        const type = this.tsTryParseTypeAnnotation();
        if (type) {
          param.typeAnnotation = type;
          this.resetEndLocation(param);
        }
        return param;
      }
      tsInAmbientContext(cb) {
        const oldIsAmbientContext = this.state.isAmbientContext;
        this.state.isAmbientContext = true;
        try {
          return cb();
        } finally {
          this.state.isAmbientContext = oldIsAmbientContext;
        }
      }
      parseClass(node2, isStatement, optionalId) {
        const oldInAbstractClass = this.state.inAbstractClass;
        this.state.inAbstractClass = !!node2.abstract;
        try {
          return super.parseClass(node2, isStatement, optionalId);
        } finally {
          this.state.inAbstractClass = oldInAbstractClass;
        }
      }
      tsParseAbstractDeclaration(node2, decorators) {
        if (this.match(80)) {
          node2.abstract = true;
          return this.maybeTakeDecorators(decorators, this.parseClass(node2, true, false));
        } else if (this.isContextual(127)) {
          if (!this.hasFollowingLineBreak()) {
            node2.abstract = true;
            this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
              at: node2
            });
            return this.tsParseInterfaceDeclaration(node2);
          }
        } else {
          this.unexpected(null, 80);
        }
      }
      parseMethod(node2, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
        const method = super.parseMethod(node2, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
        if (method.abstract) {
          const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
          if (hasBody) {
            const {
              key: key2
            } = method;
            this.raise(TSErrors.AbstractMethodHasImplementation, {
              at: method,
              methodName: key2.type === "Identifier" && !method.computed ? key2.name : `[${this.input.slice(key2.start, key2.end)}]`
            });
          }
        }
        return method;
      }
      tsParseTypeParameterName() {
        const typeName = this.parseIdentifier();
        return typeName.name;
      }
      shouldParseAsAmbientContext() {
        return !!this.getPluginOption("typescript", "dts");
      }
      parse() {
        if (this.shouldParseAsAmbientContext()) {
          this.state.isAmbientContext = true;
        }
        return super.parse();
      }
      getExpression() {
        if (this.shouldParseAsAmbientContext()) {
          this.state.isAmbientContext = true;
        }
        return super.getExpression();
      }
      parseExportSpecifier(node2, isString, isInTypeExport, isMaybeTypeOnly) {
        if (!isString && isMaybeTypeOnly) {
          this.parseTypeOnlyImportExportSpecifier(node2, false, isInTypeExport);
          return this.finishNode(node2, "ExportSpecifier");
        }
        node2.exportKind = "value";
        return super.parseExportSpecifier(node2, isString, isInTypeExport, isMaybeTypeOnly);
      }
      parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
        if (!importedIsString && isMaybeTypeOnly) {
          this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
          return this.finishNode(specifier, "ImportSpecifier");
        }
        specifier.importKind = "value";
        return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
      }
      parseTypeOnlyImportExportSpecifier(node2, isImport, isInTypeOnlyImportExport) {
        const leftOfAsKey = isImport ? "imported" : "local";
        const rightOfAsKey = isImport ? "local" : "exported";
        let leftOfAs = node2[leftOfAsKey];
        let rightOfAs;
        let hasTypeSpecifier = false;
        let canParseAsKeyword = true;
        const loc = leftOfAs.loc.start;
        if (this.isContextual(93)) {
          const firstAs = this.parseIdentifier();
          if (this.isContextual(93)) {
            const secondAs = this.parseIdentifier();
            if (tokenIsKeywordOrIdentifier(this.state.type)) {
              hasTypeSpecifier = true;
              leftOfAs = firstAs;
              rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
              canParseAsKeyword = false;
            } else {
              rightOfAs = secondAs;
              canParseAsKeyword = false;
            }
          } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
            canParseAsKeyword = false;
            rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
          } else {
            hasTypeSpecifier = true;
            leftOfAs = firstAs;
          }
        } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
          hasTypeSpecifier = true;
          if (isImport) {
            leftOfAs = this.parseIdentifier(true);
            if (!this.isContextual(93)) {
              this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
            }
          } else {
            leftOfAs = this.parseModuleExportName();
          }
        }
        if (hasTypeSpecifier && isInTypeOnlyImportExport) {
          this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
            at: loc
          });
        }
        node2[leftOfAsKey] = leftOfAs;
        node2[rightOfAsKey] = rightOfAs;
        const kindKey = isImport ? "importKind" : "exportKind";
        node2[kindKey] = hasTypeSpecifier ? "type" : "value";
        if (canParseAsKeyword && this.eatContextual(93)) {
          node2[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
        }
        if (!node2[rightOfAsKey]) {
          node2[rightOfAsKey] = cloneIdentifier(node2[leftOfAsKey]);
        }
        if (isImport) {
          this.checkIdentifier(node2[rightOfAsKey], hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
        }
      }
    };
    function isPossiblyLiteralEnum(expression) {
      if (expression.type !== "MemberExpression")
        return false;
      const {
        computed,
        property
      } = expression;
      if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
        return false;
      }
      return isUncomputedMemberExpressionChain(expression.object);
    }
    function isValidAmbientConstInitializer(expression, estree2) {
      var _expression$extra;
      const {
        type
      } = expression;
      if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
        return false;
      }
      if (estree2) {
        if (type === "Literal") {
          const {
            value: value2
          } = expression;
          if (typeof value2 === "string" || typeof value2 === "boolean") {
            return true;
          }
        }
      } else {
        if (type === "StringLiteral" || type === "BooleanLiteral") {
          return true;
        }
      }
      if (isNumber(expression, estree2) || isNegativeNumber(expression, estree2)) {
        return true;
      }
      if (type === "TemplateLiteral" && expression.expressions.length === 0) {
        return true;
      }
      if (isPossiblyLiteralEnum(expression)) {
        return true;
      }
      return false;
    }
    function isNumber(expression, estree2) {
      if (estree2) {
        return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
      } else {
        return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
      }
    }
    function isNegativeNumber(expression, estree2) {
      if (expression.type === "UnaryExpression") {
        const {
          operator,
          argument
        } = expression;
        if (operator === "-" && isNumber(argument, estree2)) {
          return true;
        }
      }
      return false;
    }
    function isUncomputedMemberExpressionChain(expression) {
      if (expression.type === "Identifier")
        return true;
      if (expression.type !== "MemberExpression")
        return false;
      if (expression.computed)
        return false;
      return isUncomputedMemberExpressionChain(expression.object);
    }
    var PlaceholderErrors = ParseErrorEnum`placeholders`({
      ClassNameIsRequired: "A class name is required.",
      UnexpectedSpace: "Unexpected space in placeholder."
    });
    var placeholders = (superClass) => class PlaceholdersParserMixin extends superClass {
      parsePlaceholder(expectedNode) {
        if (this.match(142)) {
          const node2 = this.startNode();
          this.next();
          this.assertNoSpace();
          node2.name = super.parseIdentifier(true);
          this.assertNoSpace();
          this.expect(142);
          return this.finishPlaceholder(node2, expectedNode);
        }
      }
      finishPlaceholder(node2, expectedNode) {
        const isFinished = !!(node2.expectedNode && node2.type === "Placeholder");
        node2.expectedNode = expectedNode;
        return isFinished ? node2 : this.finishNode(node2, "Placeholder");
      }
      getTokenFromCode(code2) {
        if (code2 === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
          this.finishOp(142, 2);
        } else {
          super.getTokenFromCode(code2);
        }
      }
      parseExprAtom(refExpressionErrors) {
        return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
      }
      parseIdentifier(liberal) {
        return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
      }
      checkReservedWord(word, startLoc, checkKeywords, isBinding) {
        if (word !== void 0) {
          super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
        }
      }
      parseBindingAtom() {
        return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
      }
      isValidLVal(type, isParenthesized, binding) {
        return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
      }
      toAssignable(node2, isLHS) {
        if (node2 && node2.type === "Placeholder" && node2.expectedNode === "Expression") {
          node2.expectedNode = "Pattern";
        } else {
          super.toAssignable(node2, isLHS);
        }
      }
      chStartsBindingIdentifier(ch, pos2) {
        if (super.chStartsBindingIdentifier(ch, pos2)) {
          return true;
        }
        const nextToken = this.lookahead();
        if (nextToken.type === 142) {
          return true;
        }
        return false;
      }
      verifyBreakContinue(node2, isBreak) {
        if (node2.label && node2.label.type === "Placeholder")
          return;
        super.verifyBreakContinue(node2, isBreak);
      }
      parseExpressionStatement(node2, expr) {
        if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
          return super.parseExpressionStatement(node2, expr);
        }
        if (this.match(14)) {
          const stmt = node2;
          stmt.label = this.finishPlaceholder(expr, "Identifier");
          this.next();
          stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
          return this.finishNode(stmt, "LabeledStatement");
        }
        this.semicolon();
        node2.name = expr.name;
        return this.finishPlaceholder(node2, "Statement");
      }
      parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
        return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
      }
      parseFunctionId(requireId) {
        return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
      }
      parseClass(node2, isStatement, optionalId) {
        const type = isStatement ? "ClassDeclaration" : "ClassExpression";
        this.next();
        const oldStrict = this.state.strict;
        const placeholder = this.parsePlaceholder("Identifier");
        if (placeholder) {
          if (this.match(81) || this.match(142) || this.match(5)) {
            node2.id = placeholder;
          } else if (optionalId || !isStatement) {
            node2.id = null;
            node2.body = this.finishPlaceholder(placeholder, "ClassBody");
            return this.finishNode(node2, type);
          } else {
            throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
              at: this.state.startLoc
            });
          }
        } else {
          this.parseClassId(node2, isStatement, optionalId);
        }
        super.parseClassSuper(node2);
        node2.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node2.superClass, oldStrict);
        return this.finishNode(node2, type);
      }
      parseExport(node2, decorators) {
        const placeholder = this.parsePlaceholder("Identifier");
        if (!placeholder)
          return super.parseExport(node2, decorators);
        if (!this.isContextual(97) && !this.match(12)) {
          node2.specifiers = [];
          node2.source = null;
          node2.declaration = this.finishPlaceholder(placeholder, "Declaration");
          return this.finishNode(node2, "ExportNamedDeclaration");
        }
        this.expectPlugin("exportDefaultFrom");
        const specifier = this.startNode();
        specifier.exported = placeholder;
        node2.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
        return super.parseExport(node2, decorators);
      }
      isExportDefaultSpecifier() {
        if (this.match(65)) {
          const next = this.nextTokenStart();
          if (this.isUnparsedContextual(next, "from")) {
            if (this.input.startsWith(tokenLabelName(142), this.nextTokenStartSince(next + 4))) {
              return true;
            }
          }
        }
        return super.isExportDefaultSpecifier();
      }
      maybeParseExportDefaultSpecifier(node2) {
        if (node2.specifiers && node2.specifiers.length > 0) {
          return true;
        }
        return super.maybeParseExportDefaultSpecifier(node2);
      }
      checkExport(node2) {
        const {
          specifiers
        } = node2;
        if (specifiers != null && specifiers.length) {
          node2.specifiers = specifiers.filter((node3) => node3.exported.type === "Placeholder");
        }
        super.checkExport(node2);
        node2.specifiers = specifiers;
      }
      parseImport(node2) {
        const placeholder = this.parsePlaceholder("Identifier");
        if (!placeholder)
          return super.parseImport(node2);
        node2.specifiers = [];
        if (!this.isContextual(97) && !this.match(12)) {
          node2.source = this.finishPlaceholder(placeholder, "StringLiteral");
          this.semicolon();
          return this.finishNode(node2, "ImportDeclaration");
        }
        const specifier = this.startNodeAtNode(placeholder);
        specifier.local = placeholder;
        node2.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
        if (this.eat(12)) {
          const hasStarImport = this.maybeParseStarImportSpecifier(node2);
          if (!hasStarImport)
            this.parseNamedImportSpecifiers(node2);
        }
        this.expectContextual(97);
        node2.source = this.parseImportSource();
        this.semicolon();
        return this.finishNode(node2, "ImportDeclaration");
      }
      parseImportSource() {
        return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
      }
      assertNoSpace() {
        if (this.state.start > this.state.lastTokEndLoc.index) {
          this.raise(PlaceholderErrors.UnexpectedSpace, {
            at: this.state.lastTokEndLoc
          });
        }
      }
    };
    var v8intrinsic = (superClass) => class V8IntrinsicMixin extends superClass {
      parseV8Intrinsic() {
        if (this.match(54)) {
          const v8IntrinsicStartLoc = this.state.startLoc;
          const node2 = this.startNode();
          this.next();
          if (tokenIsIdentifier(this.state.type)) {
            const name2 = this.parseIdentifierName();
            const identifier = this.createIdentifier(node2, name2);
            identifier.type = "V8IntrinsicIdentifier";
            if (this.match(10)) {
              return identifier;
            }
          }
          this.unexpected(v8IntrinsicStartLoc);
        }
      }
      parseExprAtom(refExpressionErrors) {
        return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
      }
    };
    function hasPlugin(plugins, expectedConfig) {
      const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
      const expectedKeys = Object.keys(expectedOptions);
      const expectedOptionsIsEmpty = expectedKeys.length === 0;
      return plugins.some((p) => {
        if (typeof p === "string") {
          return expectedOptionsIsEmpty && p === expectedName;
        } else {
          const [pluginName, pluginOptions] = p;
          if (pluginName !== expectedName) {
            return false;
          }
          for (const key2 of expectedKeys) {
            if (pluginOptions[key2] !== expectedOptions[key2]) {
              return false;
            }
          }
          return true;
        }
      });
    }
    function getPluginOption(plugins, name2, option) {
      const plugin2 = plugins.find((plugin3) => {
        if (Array.isArray(plugin3)) {
          return plugin3[0] === name2;
        } else {
          return plugin3 === name2;
        }
      });
      if (plugin2 && Array.isArray(plugin2) && plugin2.length > 1) {
        return plugin2[1][option];
      }
      return null;
    }
    var PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
    var TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
    var RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
    function validatePlugins(plugins) {
      if (hasPlugin(plugins, "decorators")) {
        if (hasPlugin(plugins, "decorators-legacy")) {
          throw new Error("Cannot use the decorators and decorators-legacy plugin together");
        }
        const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
        if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") {
          throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
        }
        const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
        if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
          throw new Error("'allowCallParenthesized' must be a boolean.");
        }
      }
      if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
        throw new Error("Cannot combine flow and typescript plugins.");
      }
      if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
        throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
      }
      if (hasPlugin(plugins, "pipelineOperator")) {
        const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
        if (!PIPELINE_PROPOSALS.includes(proposal)) {
          const proposalList = PIPELINE_PROPOSALS.map((p) => `"${p}"`).join(", ");
          throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
        }
        const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
          syntaxType: "hash"
        }]);
        if (proposal === "hack") {
          if (hasPlugin(plugins, "placeholders")) {
            throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
          }
          if (hasPlugin(plugins, "v8intrinsic")) {
            throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
          }
          const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
          if (!TOPIC_TOKENS.includes(topicToken)) {
            const tokenList = TOPIC_TOKENS.map((t3) => `"${t3}"`).join(", ");
            throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
          }
          if (topicToken === "#" && tupleSyntaxIsHash) {
            throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
          }
        } else if (proposal === "smart" && tupleSyntaxIsHash) {
          throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
        }
      }
      if (hasPlugin(plugins, "moduleAttributes")) {
        {
          if (hasPlugin(plugins, "importAssertions")) {
            throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
          }
          const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
          if (moduleAttributesVersionPluginOption !== "may-2020") {
            throw new Error("The 'moduleAttributes' plugin requires a 'version' option, representing the last proposal update. Currently, the only supported value is 'may-2020'.");
          }
        }
      }
      if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
        throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p) => `'${p}'`).join(", "));
      }
      if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
        const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
        error.missingPlugins = "doExpressions";
        throw error;
      }
    }
    var mixinPlugins = {
      estree,
      jsx: jsx2,
      flow: flow3,
      typescript,
      v8intrinsic,
      placeholders
    };
    var mixinPluginNames = Object.keys(mixinPlugins);
    var ExpressionParser = class extends LValParser {
      checkProto(prop, isRecord, protoRef, refExpressionErrors) {
        if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
          return;
        }
        const key2 = prop.key;
        const name2 = key2.type === "Identifier" ? key2.name : key2.value;
        if (name2 === "__proto__") {
          if (isRecord) {
            this.raise(Errors.RecordNoProto, {
              at: key2
            });
            return;
          }
          if (protoRef.used) {
            if (refExpressionErrors) {
              if (refExpressionErrors.doubleProtoLoc === null) {
                refExpressionErrors.doubleProtoLoc = key2.loc.start;
              }
            } else {
              this.raise(Errors.DuplicateProto, {
                at: key2
              });
            }
          }
          protoRef.used = true;
        }
      }
      shouldExitDescending(expr, potentialArrowAt) {
        return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt;
      }
      getExpression() {
        this.enterInitialScopes();
        this.nextToken();
        const expr = this.parseExpression();
        if (!this.match(137)) {
          this.unexpected();
        }
        this.finalizeRemainingComments();
        expr.comments = this.state.comments;
        expr.errors = this.state.errors;
        if (this.options.tokens) {
          expr.tokens = this.tokens;
        }
        return expr;
      }
      parseExpression(disallowIn, refExpressionErrors) {
        if (disallowIn) {
          return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));
        }
        return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));
      }
      parseExpressionBase(refExpressionErrors) {
        const startLoc = this.state.startLoc;
        const expr = this.parseMaybeAssign(refExpressionErrors);
        if (this.match(12)) {
          const node2 = this.startNodeAt(startLoc);
          node2.expressions = [expr];
          while (this.eat(12)) {
            node2.expressions.push(this.parseMaybeAssign(refExpressionErrors));
          }
          this.toReferencedList(node2.expressions);
          return this.finishNode(node2, "SequenceExpression");
        }
        return expr;
      }
      parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {
        return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
      }
      parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
        return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
      }
      setOptionalParametersError(refExpressionErrors, resultError) {
        var _resultError$loc;
        refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;
      }
      parseMaybeAssign(refExpressionErrors, afterLeftParse) {
        const startLoc = this.state.startLoc;
        if (this.isContextual(106)) {
          if (this.prodParam.hasYield) {
            let left2 = this.parseYield();
            if (afterLeftParse) {
              left2 = afterLeftParse.call(this, left2, startLoc);
            }
            return left2;
          }
        }
        let ownExpressionErrors;
        if (refExpressionErrors) {
          ownExpressionErrors = false;
        } else {
          refExpressionErrors = new ExpressionErrors();
          ownExpressionErrors = true;
        }
        const {
          type
        } = this.state;
        if (type === 10 || tokenIsIdentifier(type)) {
          this.state.potentialArrowAt = this.state.start;
        }
        let left = this.parseMaybeConditional(refExpressionErrors);
        if (afterLeftParse) {
          left = afterLeftParse.call(this, left, startLoc);
        }
        if (tokenIsAssignment(this.state.type)) {
          const node2 = this.startNodeAt(startLoc);
          const operator = this.state.value;
          node2.operator = operator;
          if (this.match(29)) {
            this.toAssignable(left, true);
            node2.left = left;
            const startIndex = startLoc.index;
            if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {
              refExpressionErrors.doubleProtoLoc = null;
            }
            if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {
              refExpressionErrors.shorthandAssignLoc = null;
            }
            if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {
              this.checkDestructuringPrivate(refExpressionErrors);
              refExpressionErrors.privateKeyLoc = null;
            }
          } else {
            node2.left = left;
          }
          this.next();
          node2.right = this.parseMaybeAssign();
          this.checkLVal(left, {
            in: this.finishNode(node2, "AssignmentExpression")
          });
          return node2;
        } else if (ownExpressionErrors) {
          this.checkExpressionErrors(refExpressionErrors, true);
        }
        return left;
      }
      parseMaybeConditional(refExpressionErrors) {
        const startLoc = this.state.startLoc;
        const potentialArrowAt = this.state.potentialArrowAt;
        const expr = this.parseExprOps(refExpressionErrors);
        if (this.shouldExitDescending(expr, potentialArrowAt)) {
          return expr;
        }
        return this.parseConditional(expr, startLoc, refExpressionErrors);
      }
      parseConditional(expr, startLoc, refExpressionErrors) {
        if (this.eat(17)) {
          const node2 = this.startNodeAt(startLoc);
          node2.test = expr;
          node2.consequent = this.parseMaybeAssignAllowIn();
          this.expect(14);
          node2.alternate = this.parseMaybeAssign();
          return this.finishNode(node2, "ConditionalExpression");
        }
        return expr;
      }
      parseMaybeUnaryOrPrivate(refExpressionErrors) {
        return this.match(136) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
      }
      parseExprOps(refExpressionErrors) {
        const startLoc = this.state.startLoc;
        const potentialArrowAt = this.state.potentialArrowAt;
        const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);
        if (this.shouldExitDescending(expr, potentialArrowAt)) {
          return expr;
        }
        return this.parseExprOp(expr, startLoc, -1);
      }
      parseExprOp(left, leftStartLoc, minPrec) {
        if (this.isPrivateName(left)) {
          const value2 = this.getPrivateNameSV(left);
          if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
            this.raise(Errors.PrivateInExpectedIn, {
              at: left,
              identifierName: value2
            });
          }
          this.classScope.usePrivateName(value2, left.loc.start);
        }
        const op = this.state.type;
        if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {
          let prec = tokenOperatorPrecedence(op);
          if (prec > minPrec) {
            if (op === 39) {
              this.expectPlugin("pipelineOperator");
              if (this.state.inFSharpPipelineDirectBody) {
                return left;
              }
              this.checkPipelineAtInfixOperator(left, leftStartLoc);
            }
            const node2 = this.startNodeAt(leftStartLoc);
            node2.left = left;
            node2.operator = this.state.value;
            const logical = op === 41 || op === 42;
            const coalesce = op === 40;
            if (coalesce) {
              prec = tokenOperatorPrecedence(42);
            }
            this.next();
            if (op === 39 && this.hasPlugin(["pipelineOperator", {
              proposal: "minimal"
            }])) {
              if (this.state.type === 96 && this.prodParam.hasAwait) {
                throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, {
                  at: this.state.startLoc
                });
              }
            }
            node2.right = this.parseExprOpRightExpr(op, prec);
            const finishedNode = this.finishNode(node2, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
            const nextOp = this.state.type;
            if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
              throw this.raise(Errors.MixingCoalesceWithLogical, {
                at: this.state.startLoc
              });
            }
            return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
          }
        }
        return left;
      }
      parseExprOpRightExpr(op, prec) {
        const startLoc = this.state.startLoc;
        switch (op) {
          case 39:
            switch (this.getPluginOption("pipelineOperator", "proposal")) {
              case "hack":
                return this.withTopicBindingContext(() => {
                  return this.parseHackPipeBody();
                });
              case "smart":
                return this.withTopicBindingContext(() => {
                  if (this.prodParam.hasYield && this.isContextual(106)) {
                    throw this.raise(Errors.PipeBodyIsTighter, {
                      at: this.state.startLoc
                    });
                  }
                  return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
                });
              case "fsharp":
                return this.withSoloAwaitPermittingContext(() => {
                  return this.parseFSharpPipelineBody(prec);
                });
            }
          default:
            return this.parseExprOpBaseRightExpr(op, prec);
        }
      }
      parseExprOpBaseRightExpr(op, prec) {
        const startLoc = this.state.startLoc;
        return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);
      }
      parseHackPipeBody() {
        var _body$extra;
        const {
          startLoc
        } = this.state;
        const body = this.parseMaybeAssign();
        const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);
        if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
          this.raise(Errors.PipeUnparenthesizedBody, {
            at: startLoc,
            type: body.type
          });
        }
        if (!this.topicReferenceWasUsedInCurrentContext()) {
          this.raise(Errors.PipeTopicUnused, {
            at: startLoc
          });
        }
        return body;
      }
      checkExponentialAfterUnary(node2) {
        if (this.match(57)) {
          this.raise(Errors.UnexpectedTokenUnaryExponentiation, {
            at: node2.argument
          });
        }
      }
      parseMaybeUnary(refExpressionErrors, sawUnary) {
        const startLoc = this.state.startLoc;
        const isAwait = this.isContextual(96);
        if (isAwait && this.isAwaitAllowed()) {
          this.next();
          const expr2 = this.parseAwait(startLoc);
          if (!sawUnary)
            this.checkExponentialAfterUnary(expr2);
          return expr2;
        }
        const update = this.match(34);
        const node2 = this.startNode();
        if (tokenIsPrefix(this.state.type)) {
          node2.operator = this.state.value;
          node2.prefix = true;
          if (this.match(72)) {
            this.expectPlugin("throwExpressions");
          }
          const isDelete = this.match(89);
          this.next();
          node2.argument = this.parseMaybeUnary(null, true);
          this.checkExpressionErrors(refExpressionErrors, true);
          if (this.state.strict && isDelete) {
            const arg = node2.argument;
            if (arg.type === "Identifier") {
              this.raise(Errors.StrictDelete, {
                at: node2
              });
            } else if (this.hasPropertyAsPrivateName(arg)) {
              this.raise(Errors.DeletePrivateField, {
                at: node2
              });
            }
          }
          if (!update) {
            if (!sawUnary) {
              this.checkExponentialAfterUnary(node2);
            }
            return this.finishNode(node2, "UnaryExpression");
          }
        }
        const expr = this.parseUpdate(node2, update, refExpressionErrors);
        if (isAwait) {
          const {
            type
          } = this.state;
          const startsExpr4 = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
          if (startsExpr4 && !this.isAmbiguousAwait()) {
            this.raiseOverwrite(Errors.AwaitNotInAsyncContext, {
              at: startLoc
            });
            return this.parseAwait(startLoc);
          }
        }
        return expr;
      }
      parseUpdate(node2, update, refExpressionErrors) {
        if (update) {
          const updateExpressionNode = node2;
          this.checkLVal(updateExpressionNode.argument, {
            in: this.finishNode(updateExpressionNode, "UpdateExpression")
          });
          return node2;
        }
        const startLoc = this.state.startLoc;
        let expr = this.parseExprSubscripts(refExpressionErrors);
        if (this.checkExpressionErrors(refExpressionErrors, false))
          return expr;
        while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
          const node3 = this.startNodeAt(startLoc);
          node3.operator = this.state.value;
          node3.prefix = false;
          node3.argument = expr;
          this.next();
          this.checkLVal(expr, {
            in: expr = this.finishNode(node3, "UpdateExpression")
          });
        }
        return expr;
      }
      parseExprSubscripts(refExpressionErrors) {
        const startLoc = this.state.startLoc;
        const potentialArrowAt = this.state.potentialArrowAt;
        const expr = this.parseExprAtom(refExpressionErrors);
        if (this.shouldExitDescending(expr, potentialArrowAt)) {
          return expr;
        }
        return this.parseSubscripts(expr, startLoc);
      }
      parseSubscripts(base2, startLoc, noCalls) {
        const state = {
          optionalChainMember: false,
          maybeAsyncArrow: this.atPossibleAsyncArrow(base2),
          stop: false
        };
        do {
          base2 = this.parseSubscript(base2, startLoc, noCalls, state);
          state.maybeAsyncArrow = false;
        } while (!state.stop);
        return base2;
      }
      parseSubscript(base2, startLoc, noCalls, state) {
        const {
          type
        } = this.state;
        if (!noCalls && type === 15) {
          return this.parseBind(base2, startLoc, noCalls, state);
        } else if (tokenIsTemplate(type)) {
          return this.parseTaggedTemplateExpression(base2, startLoc, state);
        }
        let optional = false;
        if (type === 18) {
          if (noCalls) {
            this.raise(Errors.OptionalChainingNoNew, {
              at: this.state.startLoc
            });
            if (this.lookaheadCharCode() === 40) {
              state.stop = true;
              return base2;
            }
          }
          state.optionalChainMember = optional = true;
          this.next();
        }
        if (!noCalls && this.match(10)) {
          return this.parseCoverCallAndAsyncArrowHead(base2, startLoc, state, optional);
        } else {
          const computed = this.eat(0);
          if (computed || optional || this.eat(16)) {
            return this.parseMember(base2, startLoc, state, computed, optional);
          } else {
            state.stop = true;
            return base2;
          }
        }
      }
      parseMember(base2, startLoc, state, computed, optional) {
        const node2 = this.startNodeAt(startLoc);
        node2.object = base2;
        node2.computed = computed;
        if (computed) {
          node2.property = this.parseExpression();
          this.expect(3);
        } else if (this.match(136)) {
          if (base2.type === "Super") {
            this.raise(Errors.SuperPrivateField, {
              at: startLoc
            });
          }
          this.classScope.usePrivateName(this.state.value, this.state.startLoc);
          node2.property = this.parsePrivateName();
        } else {
          node2.property = this.parseIdentifier(true);
        }
        if (state.optionalChainMember) {
          node2.optional = optional;
          return this.finishNode(node2, "OptionalMemberExpression");
        } else {
          return this.finishNode(node2, "MemberExpression");
        }
      }
      parseBind(base2, startLoc, noCalls, state) {
        const node2 = this.startNodeAt(startLoc);
        node2.object = base2;
        this.next();
        node2.callee = this.parseNoCallExpr();
        state.stop = true;
        return this.parseSubscripts(this.finishNode(node2, "BindExpression"), startLoc, noCalls);
      }
      parseCoverCallAndAsyncArrowHead(base2, startLoc, state, optional) {
        const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
        let refExpressionErrors = null;
        this.state.maybeInArrowParameters = true;
        this.next();
        const node2 = this.startNodeAt(startLoc);
        node2.callee = base2;
        const {
          maybeAsyncArrow,
          optionalChainMember
        } = state;
        if (maybeAsyncArrow) {
          this.expressionScope.enter(newAsyncArrowScope());
          refExpressionErrors = new ExpressionErrors();
        }
        if (optionalChainMember) {
          node2.optional = optional;
        }
        if (optional) {
          node2.arguments = this.parseCallExpressionArguments(11);
        } else {
          node2.arguments = this.parseCallExpressionArguments(11, base2.type === "Import", base2.type !== "Super", node2, refExpressionErrors);
        }
        let finishedNode = this.finishCallExpression(node2, optionalChainMember);
        if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
          state.stop = true;
          this.checkDestructuringPrivate(refExpressionErrors);
          this.expressionScope.validateAsPattern();
          this.expressionScope.exit();
          finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);
        } else {
          if (maybeAsyncArrow) {
            this.checkExpressionErrors(refExpressionErrors, true);
            this.expressionScope.exit();
          }
          this.toReferencedArguments(finishedNode);
        }
        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
        return finishedNode;
      }
      toReferencedArguments(node2, isParenthesizedExpr) {
        this.toReferencedListDeep(node2.arguments, isParenthesizedExpr);
      }
      parseTaggedTemplateExpression(base2, startLoc, state) {
        const node2 = this.startNodeAt(startLoc);
        node2.tag = base2;
        node2.quasi = this.parseTemplate(true);
        if (state.optionalChainMember) {
          this.raise(Errors.OptionalChainingNoTemplate, {
            at: startLoc
          });
        }
        return this.finishNode(node2, "TaggedTemplateExpression");
      }
      atPossibleAsyncArrow(base2) {
        return base2.type === "Identifier" && base2.name === "async" && this.state.lastTokEndLoc.index === base2.end && !this.canInsertSemicolon() && base2.end - base2.start === 5 && base2.start === this.state.potentialArrowAt;
      }
      finishCallExpression(node2, optional) {
        if (node2.callee.type === "Import") {
          if (node2.arguments.length === 2) {
            {
              if (!this.hasPlugin("moduleAttributes")) {
                this.expectPlugin("importAssertions");
              }
            }
          }
          if (node2.arguments.length === 0 || node2.arguments.length > 2) {
            this.raise(Errors.ImportCallArity, {
              at: node2,
              maxArgumentCount: this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
            });
          } else {
            for (const arg of node2.arguments) {
              if (arg.type === "SpreadElement") {
                this.raise(Errors.ImportCallSpreadArgument, {
                  at: arg
                });
              }
            }
          }
        }
        return this.finishNode(node2, optional ? "OptionalCallExpression" : "CallExpression");
      }
      parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) {
        const elts = [];
        let first = true;
        const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
        this.state.inFSharpPipelineDirectBody = false;
        while (!this.eat(close)) {
          if (first) {
            first = false;
          } else {
            this.expect(12);
            if (this.match(close)) {
              if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
                this.raise(Errors.ImportCallArgumentTrailingComma, {
                  at: this.state.lastTokStartLoc
                });
              }
              if (nodeForExtra) {
                this.addTrailingCommaExtraToNode(nodeForExtra);
              }
              this.next();
              break;
            }
          }
          elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder));
        }
        this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
        return elts;
      }
      shouldParseAsyncArrow() {
        return this.match(19) && !this.canInsertSemicolon();
      }
      parseAsyncArrowFromCallExpression(node2, call) {
        var _call$extra;
        this.resetPreviousNodeTrailingComments(call);
        this.expect(19);
        this.parseArrowExpression(node2, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);
        if (call.innerComments) {
          setInnerComments(node2, call.innerComments);
        }
        if (call.callee.trailingComments) {
          setInnerComments(node2, call.callee.trailingComments);
        }
        return node2;
      }
      parseNoCallExpr() {
        const startLoc = this.state.startLoc;
        return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
      }
      parseExprAtom(refExpressionErrors) {
        let node2;
        let decorators = null;
        const {
          type
        } = this.state;
        switch (type) {
          case 79:
            return this.parseSuper();
          case 83:
            node2 = this.startNode();
            this.next();
            if (this.match(16)) {
              return this.parseImportMetaProperty(node2);
            }
            if (!this.match(10)) {
              this.raise(Errors.UnsupportedImport, {
                at: this.state.lastTokStartLoc
              });
            }
            return this.finishNode(node2, "Import");
          case 78:
            node2 = this.startNode();
            this.next();
            return this.finishNode(node2, "ThisExpression");
          case 90: {
            return this.parseDo(this.startNode(), false);
          }
          case 56:
          case 31: {
            this.readRegexp();
            return this.parseRegExpLiteral(this.state.value);
          }
          case 132:
            return this.parseNumericLiteral(this.state.value);
          case 133:
            return this.parseBigIntLiteral(this.state.value);
          case 134:
            return this.parseDecimalLiteral(this.state.value);
          case 131:
            return this.parseStringLiteral(this.state.value);
          case 84:
            return this.parseNullLiteral();
          case 85:
            return this.parseBooleanLiteral(true);
          case 86:
            return this.parseBooleanLiteral(false);
          case 10: {
            const canBeArrow = this.state.potentialArrowAt === this.state.start;
            return this.parseParenAndDistinguishExpression(canBeArrow);
          }
          case 2:
          case 1: {
            return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true);
          }
          case 0: {
            return this.parseArrayLike(3, true, false, refExpressionErrors);
          }
          case 6:
          case 7: {
            return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);
          }
          case 5: {
            return this.parseObjectLike(8, false, false, refExpressionErrors);
          }
          case 68:
            return this.parseFunctionOrFunctionSent();
          case 26:
            decorators = this.parseDecorators();
          case 80:
            return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);
          case 77:
            return this.parseNewOrNewTarget();
          case 25:
          case 24:
            return this.parseTemplate(false);
          case 15: {
            node2 = this.startNode();
            this.next();
            node2.object = null;
            const callee = node2.callee = this.parseNoCallExpr();
            if (callee.type === "MemberExpression") {
              return this.finishNode(node2, "BindExpression");
            } else {
              throw this.raise(Errors.UnsupportedBind, {
                at: callee
              });
            }
          }
          case 136: {
            this.raise(Errors.PrivateInExpectedIn, {
              at: this.state.startLoc,
              identifierName: this.state.value
            });
            return this.parsePrivateName();
          }
          case 33: {
            return this.parseTopicReferenceThenEqualsSign(54, "%");
          }
          case 32: {
            return this.parseTopicReferenceThenEqualsSign(44, "^");
          }
          case 37:
          case 38: {
            return this.parseTopicReference("hack");
          }
          case 44:
          case 54:
          case 27: {
            const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
            if (pipeProposal) {
              return this.parseTopicReference(pipeProposal);
            }
            this.unexpected();
            break;
          }
          case 47: {
            const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
            if (isIdentifierStart3(lookaheadCh) || lookaheadCh === 62) {
              this.expectOnePlugin(["jsx", "flow", "typescript"]);
            } else {
              this.unexpected();
            }
            break;
          }
          default:
            if (tokenIsIdentifier(type)) {
              if (this.isContextual(125) && this.lookaheadInLineCharCode() === 123) {
                return this.parseModuleExpression();
              }
              const canBeArrow = this.state.potentialArrowAt === this.state.start;
              const containsEsc = this.state.containsEsc;
              const id = this.parseIdentifier();
              if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
                const {
                  type: type2
                } = this.state;
                if (type2 === 68) {
                  this.resetPreviousNodeTrailingComments(id);
                  this.next();
                  return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
                } else if (tokenIsIdentifier(type2)) {
                  if (this.lookaheadCharCode() === 61) {
                    return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
                  } else {
                    return id;
                  }
                } else if (type2 === 90) {
                  this.resetPreviousNodeTrailingComments(id);
                  return this.parseDo(this.startNodeAtNode(id), true);
                }
              }
              if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {
                this.next();
                return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
              }
              return id;
            } else {
              this.unexpected();
            }
        }
      }
      parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {
        const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
        if (pipeProposal) {
          this.state.type = topicTokenType;
          this.state.value = topicTokenValue;
          this.state.pos--;
          this.state.end--;
          this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);
          return this.parseTopicReference(pipeProposal);
        } else {
          this.unexpected();
        }
      }
      parseTopicReference(pipeProposal) {
        const node2 = this.startNode();
        const startLoc = this.state.startLoc;
        const tokenType = this.state.type;
        this.next();
        return this.finishTopicReference(node2, startLoc, pipeProposal, tokenType);
      }
      finishTopicReference(node2, startLoc, pipeProposal, tokenType) {
        if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
          const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
          if (!this.topicReferenceIsAllowedInCurrentContext()) {
            this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, {
              at: startLoc
            });
          }
          this.registerTopicReference();
          return this.finishNode(node2, nodeType);
        } else {
          throw this.raise(Errors.PipeTopicUnconfiguredToken, {
            at: startLoc,
            token: tokenLabelName(tokenType)
          });
        }
      }
      testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
        switch (pipeProposal) {
          case "hack": {
            return this.hasPlugin(["pipelineOperator", {
              topicToken: tokenLabelName(tokenType)
            }]);
          }
          case "smart":
            return tokenType === 27;
          default:
            throw this.raise(Errors.PipeTopicRequiresHackPipes, {
              at: startLoc
            });
        }
      }
      parseAsyncArrowUnaryFunction(node2) {
        this.prodParam.enter(functionFlags3(true, this.prodParam.hasYield));
        const params = [this.parseIdentifier()];
        this.prodParam.exit();
        if (this.hasPrecedingLineBreak()) {
          this.raise(Errors.LineTerminatorBeforeArrow, {
            at: this.state.curPosition()
          });
        }
        this.expect(19);
        return this.parseArrowExpression(node2, params, true);
      }
      parseDo(node2, isAsync) {
        this.expectPlugin("doExpressions");
        if (isAsync) {
          this.expectPlugin("asyncDoExpressions");
        }
        node2.async = isAsync;
        this.next();
        const oldLabels = this.state.labels;
        this.state.labels = [];
        if (isAsync) {
          this.prodParam.enter(PARAM_AWAIT);
          node2.body = this.parseBlock();
          this.prodParam.exit();
        } else {
          node2.body = this.parseBlock();
        }
        this.state.labels = oldLabels;
        return this.finishNode(node2, "DoExpression");
      }
      parseSuper() {
        const node2 = this.startNode();
        this.next();
        if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
          this.raise(Errors.SuperNotAllowed, {
            at: node2
          });
        } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
          this.raise(Errors.UnexpectedSuper, {
            at: node2
          });
        }
        if (!this.match(10) && !this.match(0) && !this.match(16)) {
          this.raise(Errors.UnsupportedSuper, {
            at: node2
          });
        }
        return this.finishNode(node2, "Super");
      }
      parsePrivateName() {
        const node2 = this.startNode();
        const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1));
        const name2 = this.state.value;
        this.next();
        node2.id = this.createIdentifier(id, name2);
        return this.finishNode(node2, "PrivateName");
      }
      parseFunctionOrFunctionSent() {
        const node2 = this.startNode();
        this.next();
        if (this.prodParam.hasYield && this.match(16)) {
          const meta = this.createIdentifier(this.startNodeAtNode(node2), "function");
          this.next();
          if (this.match(102)) {
            this.expectPlugin("functionSent");
          } else if (!this.hasPlugin("functionSent")) {
            this.unexpected();
          }
          return this.parseMetaProperty(node2, meta, "sent");
        }
        return this.parseFunction(node2);
      }
      parseMetaProperty(node2, meta, propertyName) {
        node2.meta = meta;
        const containsEsc = this.state.containsEsc;
        node2.property = this.parseIdentifier(true);
        if (node2.property.name !== propertyName || containsEsc) {
          this.raise(Errors.UnsupportedMetaProperty, {
            at: node2.property,
            target: meta.name,
            onlyValidPropertyName: propertyName
          });
        }
        return this.finishNode(node2, "MetaProperty");
      }
      parseImportMetaProperty(node2) {
        const id = this.createIdentifier(this.startNodeAtNode(node2), "import");
        this.next();
        if (this.isContextual(100)) {
          if (!this.inModule) {
            this.raise(Errors.ImportMetaOutsideModule, {
              at: id
            });
          }
          this.sawUnambiguousESM = true;
        }
        return this.parseMetaProperty(node2, id, "meta");
      }
      parseLiteralAtNode(value2, type, node2) {
        this.addExtra(node2, "rawValue", value2);
        this.addExtra(node2, "raw", this.input.slice(node2.start, this.state.end));
        node2.value = value2;
        this.next();
        return this.finishNode(node2, type);
      }
      parseLiteral(value2, type) {
        const node2 = this.startNode();
        return this.parseLiteralAtNode(value2, type, node2);
      }
      parseStringLiteral(value2) {
        return this.parseLiteral(value2, "StringLiteral");
      }
      parseNumericLiteral(value2) {
        return this.parseLiteral(value2, "NumericLiteral");
      }
      parseBigIntLiteral(value2) {
        return this.parseLiteral(value2, "BigIntLiteral");
      }
      parseDecimalLiteral(value2) {
        return this.parseLiteral(value2, "DecimalLiteral");
      }
      parseRegExpLiteral(value2) {
        const node2 = this.parseLiteral(value2.value, "RegExpLiteral");
        node2.pattern = value2.pattern;
        node2.flags = value2.flags;
        return node2;
      }
      parseBooleanLiteral(value2) {
        const node2 = this.startNode();
        node2.value = value2;
        this.next();
        return this.finishNode(node2, "BooleanLiteral");
      }
      parseNullLiteral() {
        const node2 = this.startNode();
        this.next();
        return this.finishNode(node2, "NullLiteral");
      }
      parseParenAndDistinguishExpression(canBeArrow) {
        const startLoc = this.state.startLoc;
        let val;
        this.next();
        this.expressionScope.enter(newArrowHeadScope());
        const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
        const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
        this.state.maybeInArrowParameters = true;
        this.state.inFSharpPipelineDirectBody = false;
        const innerStartLoc = this.state.startLoc;
        const exprList = [];
        const refExpressionErrors = new ExpressionErrors();
        let first = true;
        let spreadStartLoc;
        let optionalCommaStartLoc;
        while (!this.match(11)) {
          if (first) {
            first = false;
          } else {
            this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
            if (this.match(11)) {
              optionalCommaStartLoc = this.state.startLoc;
              break;
            }
          }
          if (this.match(21)) {
            const spreadNodeStartLoc = this.state.startLoc;
            spreadStartLoc = this.state.startLoc;
            exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));
            if (!this.checkCommaAfterRest(41)) {
              break;
            }
          } else {
            exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));
          }
        }
        const innerEndLoc = this.state.lastTokEndLoc;
        this.expect(11);
        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
        this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
        let arrowNode = this.startNodeAt(startLoc);
        if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
          this.checkDestructuringPrivate(refExpressionErrors);
          this.expressionScope.validateAsPattern();
          this.expressionScope.exit();
          this.parseArrowExpression(arrowNode, exprList, false);
          return arrowNode;
        }
        this.expressionScope.exit();
        if (!exprList.length) {
          this.unexpected(this.state.lastTokStartLoc);
        }
        if (optionalCommaStartLoc)
          this.unexpected(optionalCommaStartLoc);
        if (spreadStartLoc)
          this.unexpected(spreadStartLoc);
        this.checkExpressionErrors(refExpressionErrors, true);
        this.toReferencedListDeep(exprList, true);
        if (exprList.length > 1) {
          val = this.startNodeAt(innerStartLoc);
          val.expressions = exprList;
          this.finishNode(val, "SequenceExpression");
          this.resetEndLocation(val, innerEndLoc);
        } else {
          val = exprList[0];
        }
        return this.wrapParenthesis(startLoc, val);
      }
      wrapParenthesis(startLoc, expression) {
        if (!this.options.createParenthesizedExpressions) {
          this.addExtra(expression, "parenthesized", true);
          this.addExtra(expression, "parenStart", startLoc.index);
          this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
          return expression;
        }
        const parenExpression = this.startNodeAt(startLoc);
        parenExpression.expression = expression;
        return this.finishNode(parenExpression, "ParenthesizedExpression");
      }
      shouldParseArrow(params) {
        return !this.canInsertSemicolon();
      }
      parseArrow(node2) {
        if (this.eat(19)) {
          return node2;
        }
      }
      parseParenItem(node2, startLoc) {
        return node2;
      }
      parseNewOrNewTarget() {
        const node2 = this.startNode();
        this.next();
        if (this.match(16)) {
          const meta = this.createIdentifier(this.startNodeAtNode(node2), "new");
          this.next();
          const metaProp = this.parseMetaProperty(node2, meta, "target");
          if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
            this.raise(Errors.UnexpectedNewTarget, {
              at: metaProp
            });
          }
          return metaProp;
        }
        return this.parseNew(node2);
      }
      parseNew(node2) {
        this.parseNewCallee(node2);
        if (this.eat(10)) {
          const args = this.parseExprList(11);
          this.toReferencedList(args);
          node2.arguments = args;
        } else {
          node2.arguments = [];
        }
        return this.finishNode(node2, "NewExpression");
      }
      parseNewCallee(node2) {
        node2.callee = this.parseNoCallExpr();
        if (node2.callee.type === "Import") {
          this.raise(Errors.ImportCallNotNewExpression, {
            at: node2.callee
          });
        }
      }
      parseTemplateElement(isTagged) {
        const {
          start: start3,
          startLoc,
          end,
          value: value2
        } = this.state;
        const elemStart = start3 + 1;
        const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
        if (value2 === null) {
          if (!isTagged) {
            this.raise(Errors.InvalidEscapeSequenceTemplate, {
              at: createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1)
            });
          }
        }
        const isTail = this.match(24);
        const endOffset = isTail ? -1 : -2;
        const elemEnd = end + endOffset;
        elem.value = {
          raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"),
          cooked: value2 === null ? null : value2.slice(1, endOffset)
        };
        elem.tail = isTail;
        this.next();
        const finishedNode = this.finishNode(elem, "TemplateElement");
        this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
        return finishedNode;
      }
      parseTemplate(isTagged) {
        const node2 = this.startNode();
        node2.expressions = [];
        let curElt = this.parseTemplateElement(isTagged);
        node2.quasis = [curElt];
        while (!curElt.tail) {
          node2.expressions.push(this.parseTemplateSubstitution());
          this.readTemplateContinuation();
          node2.quasis.push(curElt = this.parseTemplateElement(isTagged));
        }
        return this.finishNode(node2, "TemplateLiteral");
      }
      parseTemplateSubstitution() {
        return this.parseExpression();
      }
      parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
        if (isRecord) {
          this.expectPlugin("recordAndTuple");
        }
        const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
        this.state.inFSharpPipelineDirectBody = false;
        const propHash = /* @__PURE__ */ Object.create(null);
        let first = true;
        const node2 = this.startNode();
        node2.properties = [];
        this.next();
        while (!this.match(close)) {
          if (first) {
            first = false;
          } else {
            this.expect(12);
            if (this.match(close)) {
              this.addTrailingCommaExtraToNode(node2);
              break;
            }
          }
          let prop;
          if (isPattern) {
            prop = this.parseBindingProperty();
          } else {
            prop = this.parsePropertyDefinition(refExpressionErrors);
            this.checkProto(prop, isRecord, propHash, refExpressionErrors);
          }
          if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
            this.raise(Errors.InvalidRecordProperty, {
              at: prop
            });
          }
          if (prop.shorthand) {
            this.addExtra(prop, "shorthand", true);
          }
          node2.properties.push(prop);
        }
        this.next();
        this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
        let type = "ObjectExpression";
        if (isPattern) {
          type = "ObjectPattern";
        } else if (isRecord) {
          type = "RecordExpression";
        }
        return this.finishNode(node2, type);
      }
      addTrailingCommaExtraToNode(node2) {
        this.addExtra(node2, "trailingComma", this.state.lastTokStart);
        this.addExtra(node2, "trailingCommaLoc", this.state.lastTokStartLoc, false);
      }
      maybeAsyncOrAccessorProp(prop) {
        return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));
      }
      parsePropertyDefinition(refExpressionErrors) {
        let decorators = [];
        if (this.match(26)) {
          if (this.hasPlugin("decorators")) {
            this.raise(Errors.UnsupportedPropertyDecorator, {
              at: this.state.startLoc
            });
          }
          while (this.match(26)) {
            decorators.push(this.parseDecorator());
          }
        }
        const prop = this.startNode();
        let isAsync = false;
        let isAccessor = false;
        let startLoc;
        if (this.match(21)) {
          if (decorators.length)
            this.unexpected();
          return this.parseSpread();
        }
        if (decorators.length) {
          prop.decorators = decorators;
          decorators = [];
        }
        prop.method = false;
        if (refExpressionErrors) {
          startLoc = this.state.startLoc;
        }
        let isGenerator = this.eat(55);
        this.parsePropertyNamePrefixOperator(prop);
        const containsEsc = this.state.containsEsc;
        const key2 = this.parsePropertyName(prop, refExpressionErrors);
        if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
          const keyName = key2.name;
          if (keyName === "async" && !this.hasPrecedingLineBreak()) {
            isAsync = true;
            this.resetPreviousNodeTrailingComments(key2);
            isGenerator = this.eat(55);
            this.parsePropertyName(prop);
          }
          if (keyName === "get" || keyName === "set") {
            isAccessor = true;
            this.resetPreviousNodeTrailingComments(key2);
            prop.kind = keyName;
            if (this.match(55)) {
              isGenerator = true;
              this.raise(Errors.AccessorIsGenerator, {
                at: this.state.curPosition(),
                kind: keyName
              });
              this.next();
            }
            this.parsePropertyName(prop);
          }
        }
        return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
      }
      getGetterSetterExpectedParamCount(method) {
        return method.kind === "get" ? 0 : 1;
      }
      getObjectOrClassMethodParams(method) {
        return method.params;
      }
      checkGetterSetterParams(method) {
        var _params;
        const paramCount = this.getGetterSetterExpectedParamCount(method);
        const params = this.getObjectOrClassMethodParams(method);
        if (params.length !== paramCount) {
          this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
            at: method
          });
        }
        if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
          this.raise(Errors.BadSetterRestParameter, {
            at: method
          });
        }
      }
      parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
        if (isAccessor) {
          const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
          this.checkGetterSetterParams(finishedProp);
          return finishedProp;
        }
        if (isAsync || isGenerator || this.match(10)) {
          if (isPattern)
            this.unexpected();
          prop.kind = "method";
          prop.method = true;
          return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
        }
      }
      parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
        prop.shorthand = false;
        if (this.eat(14)) {
          prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);
          return this.finishNode(prop, "ObjectProperty");
        }
        if (!prop.computed && prop.key.type === "Identifier") {
          this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
          if (isPattern) {
            prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
          } else if (this.match(29)) {
            const shorthandAssignLoc = this.state.startLoc;
            if (refExpressionErrors != null) {
              if (refExpressionErrors.shorthandAssignLoc === null) {
                refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
              }
            } else {
              this.raise(Errors.InvalidCoverInitializedName, {
                at: shorthandAssignLoc
              });
            }
            prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
          } else {
            prop.value = cloneIdentifier(prop.key);
          }
          prop.shorthand = true;
          return this.finishNode(prop, "ObjectProperty");
        }
      }
      parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
        const node2 = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
        if (!node2)
          this.unexpected();
        return node2;
      }
      parsePropertyName(prop, refExpressionErrors) {
        if (this.eat(0)) {
          prop.computed = true;
          prop.key = this.parseMaybeAssignAllowIn();
          this.expect(3);
        } else {
          const {
            type,
            value: value2
          } = this.state;
          let key2;
          if (tokenIsKeywordOrIdentifier(type)) {
            key2 = this.parseIdentifier(true);
          } else {
            switch (type) {
              case 132:
                key2 = this.parseNumericLiteral(value2);
                break;
              case 131:
                key2 = this.parseStringLiteral(value2);
                break;
              case 133:
                key2 = this.parseBigIntLiteral(value2);
                break;
              case 134:
                key2 = this.parseDecimalLiteral(value2);
                break;
              case 136: {
                const privateKeyLoc = this.state.startLoc;
                if (refExpressionErrors != null) {
                  if (refExpressionErrors.privateKeyLoc === null) {
                    refExpressionErrors.privateKeyLoc = privateKeyLoc;
                  }
                } else {
                  this.raise(Errors.UnexpectedPrivateField, {
                    at: privateKeyLoc
                  });
                }
                key2 = this.parsePrivateName();
                break;
              }
              default:
                this.unexpected();
            }
          }
          prop.key = key2;
          if (type !== 136) {
            prop.computed = false;
          }
        }
        return prop.key;
      }
      initFunction(node2, isAsync) {
        node2.id = null;
        node2.generator = false;
        node2.async = isAsync;
      }
      parseMethod(node2, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
        this.initFunction(node2, isAsync);
        node2.generator = isGenerator;
        this.scope.enter(SCOPE_FUNCTION3 | SCOPE_SUPER3 | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER3 : 0));
        this.prodParam.enter(functionFlags3(isAsync, node2.generator));
        this.parseFunctionParams(node2, isConstructor);
        const finishedNode = this.parseFunctionBodyAndFinish(node2, type, true);
        this.prodParam.exit();
        this.scope.exit();
        return finishedNode;
      }
      parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
        if (isTuple) {
          this.expectPlugin("recordAndTuple");
        }
        const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
        this.state.inFSharpPipelineDirectBody = false;
        const node2 = this.startNode();
        this.next();
        node2.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node2);
        this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
        return this.finishNode(node2, isTuple ? "TupleExpression" : "ArrayExpression");
      }
      parseArrowExpression(node2, params, isAsync, trailingCommaLoc) {
        this.scope.enter(SCOPE_FUNCTION3 | SCOPE_ARROW3);
        let flags = functionFlags3(isAsync, false);
        if (!this.match(5) && this.prodParam.hasIn) {
          flags |= PARAM_IN;
        }
        this.prodParam.enter(flags);
        this.initFunction(node2, isAsync);
        const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
        if (params) {
          this.state.maybeInArrowParameters = true;
          this.setArrowFunctionParameters(node2, params, trailingCommaLoc);
        }
        this.state.maybeInArrowParameters = false;
        this.parseFunctionBody(node2, true);
        this.prodParam.exit();
        this.scope.exit();
        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
        return this.finishNode(node2, "ArrowFunctionExpression");
      }
      setArrowFunctionParameters(node2, params, trailingCommaLoc) {
        this.toAssignableList(params, trailingCommaLoc, false);
        node2.params = params;
      }
      parseFunctionBodyAndFinish(node2, type, isMethod = false) {
        this.parseFunctionBody(node2, false, isMethod);
        return this.finishNode(node2, type);
      }
      parseFunctionBody(node2, allowExpression, isMethod = false) {
        const isExpression = allowExpression && !this.match(5);
        this.expressionScope.enter(newExpressionScope());
        if (isExpression) {
          node2.body = this.parseMaybeAssign();
          this.checkParams(node2, false, allowExpression, false);
        } else {
          const oldStrict = this.state.strict;
          const oldLabels = this.state.labels;
          this.state.labels = [];
          this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);
          node2.body = this.parseBlock(true, false, (hasStrictModeDirective) => {
            const nonSimple = !this.isSimpleParamList(node2.params);
            if (hasStrictModeDirective && nonSimple) {
              this.raise(Errors.IllegalLanguageModeDirective, {
                at: (node2.kind === "method" || node2.kind === "constructor") && !!node2.key ? node2.key.loc.end : node2
              });
            }
            const strictModeChanged = !oldStrict && this.state.strict;
            this.checkParams(node2, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
            if (this.state.strict && node2.id) {
              this.checkIdentifier(node2.id, BIND_OUTSIDE3, strictModeChanged);
            }
          });
          this.prodParam.exit();
          this.state.labels = oldLabels;
        }
        this.expressionScope.exit();
      }
      isSimpleParameter(node2) {
        return node2.type === "Identifier";
      }
      isSimpleParamList(params) {
        for (let i = 0, len = params.length; i < len; i++) {
          if (!this.isSimpleParameter(params[i]))
            return false;
        }
        return true;
      }
      checkParams(node2, allowDuplicates, isArrowFunction, strictModeChanged = true) {
        const checkClashes = !allowDuplicates && /* @__PURE__ */ new Set();
        const formalParameters = {
          type: "FormalParameters"
        };
        for (const param of node2.params) {
          this.checkLVal(param, {
            in: formalParameters,
            binding: BIND_VAR3,
            checkClashes,
            strictModeChanged
          });
        }
      }
      parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {
        const elts = [];
        let first = true;
        while (!this.eat(close)) {
          if (first) {
            first = false;
          } else {
            this.expect(12);
            if (this.match(close)) {
              if (nodeForExtra) {
                this.addTrailingCommaExtraToNode(nodeForExtra);
              }
              this.next();
              break;
            }
          }
          elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));
        }
        return elts;
      }
      parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) {
        let elt;
        if (this.match(12)) {
          if (!allowEmpty) {
            this.raise(Errors.UnexpectedToken, {
              at: this.state.curPosition(),
              unexpected: ","
            });
          }
          elt = null;
        } else if (this.match(21)) {
          const spreadNodeStartLoc = this.state.startLoc;
          elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
        } else if (this.match(17)) {
          this.expectPlugin("partialApplication");
          if (!allowPlaceholder) {
            this.raise(Errors.UnexpectedArgumentPlaceholder, {
              at: this.state.startLoc
            });
          }
          const node2 = this.startNode();
          this.next();
          elt = this.finishNode(node2, "ArgumentPlaceholder");
        } else {
          elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem);
        }
        return elt;
      }
      parseIdentifier(liberal) {
        const node2 = this.startNode();
        const name2 = this.parseIdentifierName(liberal);
        return this.createIdentifier(node2, name2);
      }
      createIdentifier(node2, name2) {
        node2.name = name2;
        node2.loc.identifierName = name2;
        return this.finishNode(node2, "Identifier");
      }
      parseIdentifierName(liberal) {
        let name2;
        const {
          startLoc,
          type
        } = this.state;
        if (tokenIsKeywordOrIdentifier(type)) {
          name2 = this.state.value;
        } else {
          this.unexpected();
        }
        const tokenIsKeyword2 = tokenKeywordOrIdentifierIsKeyword(type);
        if (liberal) {
          if (tokenIsKeyword2) {
            this.replaceToken(130);
          }
        } else {
          this.checkReservedWord(name2, startLoc, tokenIsKeyword2, false);
        }
        this.next();
        return name2;
      }
      checkReservedWord(word, startLoc, checkKeywords, isBinding) {
        if (word.length > 10) {
          return;
        }
        if (!canBeReservedWord(word)) {
          return;
        }
        if (checkKeywords && isKeyword(word)) {
          this.raise(Errors.UnexpectedKeyword, {
            at: startLoc,
            keyword: word
          });
          return;
        }
        const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
        if (reservedTest(word, this.inModule)) {
          this.raise(Errors.UnexpectedReservedWord, {
            at: startLoc,
            reservedWord: word
          });
          return;
        } else if (word === "yield") {
          if (this.prodParam.hasYield) {
            this.raise(Errors.YieldBindingIdentifier, {
              at: startLoc
            });
            return;
          }
        } else if (word === "await") {
          if (this.prodParam.hasAwait) {
            this.raise(Errors.AwaitBindingIdentifier, {
              at: startLoc
            });
            return;
          }
          if (this.scope.inStaticBlock) {
            this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {
              at: startLoc
            });
            return;
          }
          this.expressionScope.recordAsyncArrowParametersError({
            at: startLoc
          });
        } else if (word === "arguments") {
          if (this.scope.inClassAndNotInNonArrowFunction) {
            this.raise(Errors.ArgumentsInClass, {
              at: startLoc
            });
            return;
          }
        }
      }
      isAwaitAllowed() {
        if (this.prodParam.hasAwait)
          return true;
        if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {
          return true;
        }
        return false;
      }
      parseAwait(startLoc) {
        const node2 = this.startNodeAt(startLoc);
        this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, {
          at: node2
        });
        if (this.eat(55)) {
          this.raise(Errors.ObsoleteAwaitStar, {
            at: node2
          });
        }
        if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
          if (this.isAmbiguousAwait()) {
            this.ambiguousScriptDifferentAst = true;
          } else {
            this.sawUnambiguousESM = true;
          }
        }
        if (!this.state.soloAwait) {
          node2.argument = this.parseMaybeUnary(null, true);
        }
        return this.finishNode(node2, "AwaitExpression");
      }
      isAmbiguousAwait() {
        if (this.hasPrecedingLineBreak())
          return true;
        const {
          type
        } = this.state;
        return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 101 && !this.state.containsEsc || type === 135 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
      }
      parseYield() {
        const node2 = this.startNode();
        this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, {
          at: node2
        });
        this.next();
        let delegating = false;
        let argument = null;
        if (!this.hasPrecedingLineBreak()) {
          delegating = this.eat(55);
          switch (this.state.type) {
            case 13:
            case 137:
            case 8:
            case 11:
            case 3:
            case 9:
            case 14:
            case 12:
              if (!delegating)
                break;
            default:
              argument = this.parseMaybeAssign();
          }
        }
        node2.delegate = delegating;
        node2.argument = argument;
        return this.finishNode(node2, "YieldExpression");
      }
      checkPipelineAtInfixOperator(left, leftStartLoc) {
        if (this.hasPlugin(["pipelineOperator", {
          proposal: "smart"
        }])) {
          if (left.type === "SequenceExpression") {
            this.raise(Errors.PipelineHeadSequenceExpression, {
              at: leftStartLoc
            });
          }
        }
      }
      parseSmartPipelineBodyInStyle(childExpr, startLoc) {
        if (this.isSimpleReference(childExpr)) {
          const bodyNode = this.startNodeAt(startLoc);
          bodyNode.callee = childExpr;
          return this.finishNode(bodyNode, "PipelineBareFunction");
        } else {
          const bodyNode = this.startNodeAt(startLoc);
          this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
          bodyNode.expression = childExpr;
          return this.finishNode(bodyNode, "PipelineTopicExpression");
        }
      }
      isSimpleReference(expression) {
        switch (expression.type) {
          case "MemberExpression":
            return !expression.computed && this.isSimpleReference(expression.object);
          case "Identifier":
            return true;
          default:
            return false;
        }
      }
      checkSmartPipeTopicBodyEarlyErrors(startLoc) {
        if (this.match(19)) {
          throw this.raise(Errors.PipelineBodyNoArrow, {
            at: this.state.startLoc
          });
        }
        if (!this.topicReferenceWasUsedInCurrentContext()) {
          this.raise(Errors.PipelineTopicUnused, {
            at: startLoc
          });
        }
      }
      withTopicBindingContext(callback) {
        const outerContextTopicState = this.state.topicContext;
        this.state.topicContext = {
          maxNumOfResolvableTopics: 1,
          maxTopicIndex: null
        };
        try {
          return callback();
        } finally {
          this.state.topicContext = outerContextTopicState;
        }
      }
      withSmartMixTopicForbiddingContext(callback) {
        if (this.hasPlugin(["pipelineOperator", {
          proposal: "smart"
        }])) {
          const outerContextTopicState = this.state.topicContext;
          this.state.topicContext = {
            maxNumOfResolvableTopics: 0,
            maxTopicIndex: null
          };
          try {
            return callback();
          } finally {
            this.state.topicContext = outerContextTopicState;
          }
        } else {
          return callback();
        }
      }
      withSoloAwaitPermittingContext(callback) {
        const outerContextSoloAwaitState = this.state.soloAwait;
        this.state.soloAwait = true;
        try {
          return callback();
        } finally {
          this.state.soloAwait = outerContextSoloAwaitState;
        }
      }
      allowInAnd(callback) {
        const flags = this.prodParam.currentFlags();
        const prodParamToSet = PARAM_IN & ~flags;
        if (prodParamToSet) {
          this.prodParam.enter(flags | PARAM_IN);
          try {
            return callback();
          } finally {
            this.prodParam.exit();
          }
        }
        return callback();
      }
      disallowInAnd(callback) {
        const flags = this.prodParam.currentFlags();
        const prodParamToClear = PARAM_IN & flags;
        if (prodParamToClear) {
          this.prodParam.enter(flags & ~PARAM_IN);
          try {
            return callback();
          } finally {
            this.prodParam.exit();
          }
        }
        return callback();
      }
      registerTopicReference() {
        this.state.topicContext.maxTopicIndex = 0;
      }
      topicReferenceIsAllowedInCurrentContext() {
        return this.state.topicContext.maxNumOfResolvableTopics >= 1;
      }
      topicReferenceWasUsedInCurrentContext() {
        return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
      }
      parseFSharpPipelineBody(prec) {
        const startLoc = this.state.startLoc;
        this.state.potentialArrowAt = this.state.start;
        const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
        this.state.inFSharpPipelineDirectBody = true;
        const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
        this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
        return ret;
      }
      parseModuleExpression() {
        this.expectPlugin("moduleBlocks");
        const node2 = this.startNode();
        this.next();
        if (!this.match(5)) {
          this.unexpected(null, 5);
        }
        const program = this.startNodeAt(this.state.endLoc);
        this.next();
        const revertScopes = this.initializeScopes(true);
        this.enterInitialScopes();
        try {
          node2.body = this.parseProgram(program, 8, "module");
        } finally {
          revertScopes();
        }
        return this.finishNode(node2, "ModuleExpression");
      }
      parsePropertyNamePrefixOperator(prop) {
      }
    };
    var loopLabel3 = {
      kind: "loop"
    };
    var switchLabel3 = {
      kind: "switch"
    };
    var loneSurrogate2 = /[\uD800-\uDFFF]/u;
    var keywordRelationalOperator3 = /in(?:stanceof)?/y;
    function babel7CompatTokens(tokens, input) {
      for (let i = 0; i < tokens.length; i++) {
        const token2 = tokens[i];
        const {
          type
        } = token2;
        if (typeof type === "number") {
          {
            if (type === 136) {
              const {
                loc,
                start: start3,
                value: value2,
                end
              } = token2;
              const hashEndPos = start3 + 1;
              const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);
              tokens.splice(i, 1, new Token5({
                type: getExportedToken(27),
                value: "#",
                start: start3,
                end: hashEndPos,
                startLoc: loc.start,
                endLoc: hashEndLoc
              }), new Token5({
                type: getExportedToken(130),
                value: value2,
                start: hashEndPos,
                end,
                startLoc: hashEndLoc,
                endLoc: loc.end
              }));
              i++;
              continue;
            }
            if (tokenIsTemplate(type)) {
              const {
                loc,
                start: start3,
                value: value2,
                end
              } = token2;
              const backquoteEnd = start3 + 1;
              const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);
              let startToken;
              if (input.charCodeAt(start3) === 96) {
                startToken = new Token5({
                  type: getExportedToken(22),
                  value: "`",
                  start: start3,
                  end: backquoteEnd,
                  startLoc: loc.start,
                  endLoc: backquoteEndLoc
                });
              } else {
                startToken = new Token5({
                  type: getExportedToken(8),
                  value: "}",
                  start: start3,
                  end: backquoteEnd,
                  startLoc: loc.start,
                  endLoc: backquoteEndLoc
                });
              }
              let templateValue, templateElementEnd, templateElementEndLoc, endToken;
              if (type === 24) {
                templateElementEnd = end - 1;
                templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);
                templateValue = value2 === null ? null : value2.slice(1, -1);
                endToken = new Token5({
                  type: getExportedToken(22),
                  value: "`",
                  start: templateElementEnd,
                  end,
                  startLoc: templateElementEndLoc,
                  endLoc: loc.end
                });
              } else {
                templateElementEnd = end - 2;
                templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);
                templateValue = value2 === null ? null : value2.slice(1, -2);
                endToken = new Token5({
                  type: getExportedToken(23),
                  value: "${",
                  start: templateElementEnd,
                  end,
                  startLoc: templateElementEndLoc,
                  endLoc: loc.end
                });
              }
              tokens.splice(i, 1, startToken, new Token5({
                type: getExportedToken(20),
                value: templateValue,
                start: backquoteEnd,
                end: templateElementEnd,
                startLoc: backquoteEndLoc,
                endLoc: templateElementEndLoc
              }), endToken);
              i += 2;
              continue;
            }
          }
          token2.type = getExportedToken(type);
        }
      }
      return tokens;
    }
    var StatementParser = class extends ExpressionParser {
      parseTopLevel(file, program) {
        file.program = this.parseProgram(program);
        file.comments = this.state.comments;
        if (this.options.tokens) {
          file.tokens = babel7CompatTokens(this.tokens, this.input);
        }
        return this.finishNode(file, "File");
      }
      parseProgram(program, end = 137, sourceType = this.options.sourceType) {
        program.sourceType = sourceType;
        program.interpreter = this.parseInterpreterDirective();
        this.parseBlockBody(program, true, true, end);
        if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
          for (const [localName, at3] of Array.from(this.scope.undefinedExports)) {
            this.raise(Errors.ModuleExportUndefined, {
              at: at3,
              localName
            });
          }
        }
        let finishedProgram;
        if (end === 137) {
          finishedProgram = this.finishNode(program, "Program");
        } else {
          finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1));
        }
        return finishedProgram;
      }
      stmtToDirective(stmt) {
        const directive = stmt;
        directive.type = "Directive";
        directive.value = directive.expression;
        delete directive.expression;
        const directiveLiteral = directive.value;
        const expressionValue = directiveLiteral.value;
        const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);
        const val = directiveLiteral.value = raw.slice(1, -1);
        this.addExtra(directiveLiteral, "raw", raw);
        this.addExtra(directiveLiteral, "rawValue", val);
        this.addExtra(directiveLiteral, "expressionValue", expressionValue);
        directiveLiteral.type = "DirectiveLiteral";
        return directive;
      }
      parseInterpreterDirective() {
        if (!this.match(28)) {
          return null;
        }
        const node2 = this.startNode();
        node2.value = this.state.value;
        this.next();
        return this.finishNode(node2, "InterpreterDirective");
      }
      isLet() {
        if (!this.isContextual(99)) {
          return false;
        }
        return this.hasFollowingBindingAtom();
      }
      chStartsBindingIdentifier(ch, pos2) {
        if (isIdentifierStart3(ch)) {
          keywordRelationalOperator3.lastIndex = pos2;
          if (keywordRelationalOperator3.test(this.input)) {
            const endCh = this.codePointAtPos(keywordRelationalOperator3.lastIndex);
            if (!isIdentifierChar3(endCh) && endCh !== 92) {
              return false;
            }
          }
          return true;
        } else if (ch === 92) {
          return true;
        } else {
          return false;
        }
      }
      chStartsBindingPattern(ch) {
        return ch === 91 || ch === 123;
      }
      hasFollowingBindingAtom() {
        const next = this.nextTokenStart();
        const nextCh = this.codePointAtPos(next);
        return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
      }
      hasInLineFollowingBindingIdentifier() {
        const next = this.nextTokenInLineStart();
        const nextCh = this.codePointAtPos(next);
        return this.chStartsBindingIdentifier(nextCh, next);
      }
      startsUsingForOf() {
        const {
          type,
          containsEsc
        } = this.lookahead();
        if (type === 101 && !containsEsc) {
          return false;
        } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {
          this.expectPlugin("explicitResourceManagement");
          return true;
        }
      }
      parseModuleItem() {
        return this.parseStatementLike(1 | 2 | 4 | 8);
      }
      parseStatementListItem() {
        return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8));
      }
      parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
        let flags = 0;
        if (this.options.annexB && !this.state.strict) {
          flags |= 4;
          if (allowLabeledFunction) {
            flags |= 8;
          }
        }
        return this.parseStatementLike(flags);
      }
      parseStatement() {
        return this.parseStatementLike(0);
      }
      parseStatementLike(flags) {
        let decorators = null;
        if (this.match(26)) {
          decorators = this.parseDecorators(true);
        }
        return this.parseStatementContent(flags, decorators);
      }
      parseStatementContent(flags, decorators) {
        const starttype = this.state.type;
        const node2 = this.startNode();
        const allowDeclaration = !!(flags & 2);
        const allowFunctionDeclaration = !!(flags & 4);
        const topLevel = flags & 1;
        switch (starttype) {
          case 60:
            return this.parseBreakContinueStatement(node2, true);
          case 63:
            return this.parseBreakContinueStatement(node2, false);
          case 64:
            return this.parseDebuggerStatement(node2);
          case 90:
            return this.parseDoWhileStatement(node2);
          case 91:
            return this.parseForStatement(node2);
          case 68:
            if (this.lookaheadCharCode() === 46)
              break;
            if (!allowFunctionDeclaration) {
              this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, {
                at: this.state.startLoc
              });
            }
            return this.parseFunctionStatement(node2, false, !allowDeclaration && allowFunctionDeclaration);
          case 80:
            if (!allowDeclaration)
              this.unexpected();
            return this.parseClass(this.maybeTakeDecorators(decorators, node2), true);
          case 69:
            return this.parseIfStatement(node2);
          case 70:
            return this.parseReturnStatement(node2);
          case 71:
            return this.parseSwitchStatement(node2);
          case 72:
            return this.parseThrowStatement(node2);
          case 73:
            return this.parseTryStatement(node2);
          case 105:
            if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) {
              break;
            }
            this.expectPlugin("explicitResourceManagement");
            if (!this.scope.inModule && this.scope.inTopLevel) {
              this.raise(Errors.UnexpectedUsingDeclaration, {
                at: this.state.startLoc
              });
            } else if (!allowDeclaration) {
              this.raise(Errors.UnexpectedLexicalDeclaration, {
                at: this.state.startLoc
              });
            }
            return this.parseVarStatement(node2, "using");
          case 99: {
            if (this.state.containsEsc) {
              break;
            }
            const next = this.nextTokenStart();
            const nextCh = this.codePointAtPos(next);
            if (nextCh !== 91) {
              if (!allowDeclaration && this.hasFollowingLineBreak())
                break;
              if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
                break;
              }
            }
          }
          case 75: {
            if (!allowDeclaration) {
              this.raise(Errors.UnexpectedLexicalDeclaration, {
                at: this.state.startLoc
              });
            }
          }
          case 74: {
            const kind = this.state.value;
            return this.parseVarStatement(node2, kind);
          }
          case 92:
            return this.parseWhileStatement(node2);
          case 76:
            return this.parseWithStatement(node2);
          case 5:
            return this.parseBlock();
          case 13:
            return this.parseEmptyStatement(node2);
          case 83: {
            const nextTokenCharCode = this.lookaheadCharCode();
            if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
              break;
            }
          }
          case 82: {
            if (!this.options.allowImportExportEverywhere && !topLevel) {
              this.raise(Errors.UnexpectedImportExport, {
                at: this.state.startLoc
              });
            }
            this.next();
            let result;
            if (starttype === 83) {
              result = this.parseImport(node2);
              if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
                this.sawUnambiguousESM = true;
              }
            } else {
              result = this.parseExport(node2, decorators);
              if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
                this.sawUnambiguousESM = true;
              }
            }
            this.assertModuleNodeAllowed(result);
            return result;
          }
          default: {
            if (this.isAsyncFunction()) {
              if (!allowDeclaration) {
                this.raise(Errors.AsyncFunctionInSingleStatementContext, {
                  at: this.state.startLoc
                });
              }
              this.next();
              return this.parseFunctionStatement(node2, true, !allowDeclaration && allowFunctionDeclaration);
            }
          }
        }
        const maybeName = this.state.value;
        const expr = this.parseExpression();
        if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) {
          return this.parseLabeledStatement(node2, maybeName, expr, flags);
        } else {
          return this.parseExpressionStatement(node2, expr, decorators);
        }
      }
      assertModuleNodeAllowed(node2) {
        if (!this.options.allowImportExportEverywhere && !this.inModule) {
          this.raise(Errors.ImportOutsideModule, {
            at: node2
          });
        }
      }
      decoratorsEnabledBeforeExport() {
        if (this.hasPlugin("decorators-legacy"))
          return true;
        return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
      }
      maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
        if (maybeDecorators) {
          if (classNode.decorators && classNode.decorators.length > 0) {
            if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
              this.raise(Errors.DecoratorsBeforeAfterExport, {
                at: classNode.decorators[0]
              });
            }
            classNode.decorators.unshift(...maybeDecorators);
          } else {
            classNode.decorators = maybeDecorators;
          }
          this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
          if (exportNode)
            this.resetStartLocationFromNode(exportNode, classNode);
        }
        return classNode;
      }
      canHaveLeadingDecorator() {
        return this.match(80);
      }
      parseDecorators(allowExport) {
        const decorators = [];
        do {
          decorators.push(this.parseDecorator());
        } while (this.match(26));
        if (this.match(82)) {
          if (!allowExport) {
            this.unexpected();
          }
          if (!this.decoratorsEnabledBeforeExport()) {
            this.raise(Errors.DecoratorExportClass, {
              at: this.state.startLoc
            });
          }
        } else if (!this.canHaveLeadingDecorator()) {
          throw this.raise(Errors.UnexpectedLeadingDecorator, {
            at: this.state.startLoc
          });
        }
        return decorators;
      }
      parseDecorator() {
        this.expectOnePlugin(["decorators", "decorators-legacy"]);
        const node2 = this.startNode();
        this.next();
        if (this.hasPlugin("decorators")) {
          const startLoc = this.state.startLoc;
          let expr;
          if (this.match(10)) {
            const startLoc2 = this.state.startLoc;
            this.next();
            expr = this.parseExpression();
            this.expect(11);
            expr = this.wrapParenthesis(startLoc2, expr);
            const paramsStartLoc = this.state.startLoc;
            node2.expression = this.parseMaybeDecoratorArguments(expr);
            if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node2.expression !== expr) {
              this.raise(Errors.DecoratorArgumentsOutsideParentheses, {
                at: paramsStartLoc
              });
            }
          } else {
            expr = this.parseIdentifier(false);
            while (this.eat(16)) {
              const node3 = this.startNodeAt(startLoc);
              node3.object = expr;
              if (this.match(136)) {
                this.classScope.usePrivateName(this.state.value, this.state.startLoc);
                node3.property = this.parsePrivateName();
              } else {
                node3.property = this.parseIdentifier(true);
              }
              node3.computed = false;
              expr = this.finishNode(node3, "MemberExpression");
            }
            node2.expression = this.parseMaybeDecoratorArguments(expr);
          }
        } else {
          node2.expression = this.parseExprSubscripts();
        }
        return this.finishNode(node2, "Decorator");
      }
      parseMaybeDecoratorArguments(expr) {
        if (this.eat(10)) {
          const node2 = this.startNodeAtNode(expr);
          node2.callee = expr;
          node2.arguments = this.parseCallExpressionArguments(11, false);
          this.toReferencedList(node2.arguments);
          return this.finishNode(node2, "CallExpression");
        }
        return expr;
      }
      parseBreakContinueStatement(node2, isBreak) {
        this.next();
        if (this.isLineTerminator()) {
          node2.label = null;
        } else {
          node2.label = this.parseIdentifier();
          this.semicolon();
        }
        this.verifyBreakContinue(node2, isBreak);
        return this.finishNode(node2, isBreak ? "BreakStatement" : "ContinueStatement");
      }
      verifyBreakContinue(node2, isBreak) {
        let i;
        for (i = 0; i < this.state.labels.length; ++i) {
          const lab = this.state.labels[i];
          if (node2.label == null || lab.name === node2.label.name) {
            if (lab.kind != null && (isBreak || lab.kind === "loop"))
              break;
            if (node2.label && isBreak)
              break;
          }
        }
        if (i === this.state.labels.length) {
          const type = isBreak ? "BreakStatement" : "ContinueStatement";
          this.raise(Errors.IllegalBreakContinue, {
            at: node2,
            type
          });
        }
      }
      parseDebuggerStatement(node2) {
        this.next();
        this.semicolon();
        return this.finishNode(node2, "DebuggerStatement");
      }
      parseHeaderExpression() {
        this.expect(10);
        const val = this.parseExpression();
        this.expect(11);
        return val;
      }
      parseDoWhileStatement(node2) {
        this.next();
        this.state.labels.push(loopLabel3);
        node2.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
        this.state.labels.pop();
        this.expect(92);
        node2.test = this.parseHeaderExpression();
        this.eat(13);
        return this.finishNode(node2, "DoWhileStatement");
      }
      parseForStatement(node2) {
        this.next();
        this.state.labels.push(loopLabel3);
        let awaitAt = null;
        if (this.isAwaitAllowed() && this.eatContextual(96)) {
          awaitAt = this.state.lastTokStartLoc;
        }
        this.scope.enter(SCOPE_OTHER);
        this.expect(10);
        if (this.match(13)) {
          if (awaitAt !== null) {
            this.unexpected(awaitAt);
          }
          return this.parseFor(node2, null);
        }
        const startsWithLet = this.isContextual(99);
        const startsWithUsing = this.isContextual(105);
        const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || startsWithUsing && this.startsUsingForOf();
        if (this.match(74) || this.match(75) || isLetOrUsing) {
          const initNode = this.startNode();
          const kind = this.state.value;
          this.next();
          this.parseVar(initNode, true, kind);
          const init2 = this.finishNode(initNode, "VariableDeclaration");
          const isForIn = this.match(58);
          if (isForIn && startsWithUsing) {
            this.raise(Errors.ForInUsing, {
              at: init2
            });
          }
          if ((isForIn || this.isContextual(101)) && init2.declarations.length === 1) {
            return this.parseForIn(node2, init2, awaitAt);
          }
          if (awaitAt !== null) {
            this.unexpected(awaitAt);
          }
          return this.parseFor(node2, init2);
        }
        const startsWithAsync = this.isContextual(95);
        const refExpressionErrors = new ExpressionErrors();
        const init = this.parseExpression(true, refExpressionErrors);
        const isForOf = this.isContextual(101);
        if (isForOf) {
          if (startsWithLet) {
            this.raise(Errors.ForOfLet, {
              at: init
            });
          }
          if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
            this.raise(Errors.ForOfAsync, {
              at: init
            });
          }
        }
        if (isForOf || this.match(58)) {
          this.checkDestructuringPrivate(refExpressionErrors);
          this.toAssignable(init, true);
          const type = isForOf ? "ForOfStatement" : "ForInStatement";
          this.checkLVal(init, {
            in: {
              type
            }
          });
          return this.parseForIn(node2, init, awaitAt);
        } else {
          this.checkExpressionErrors(refExpressionErrors, true);
        }
        if (awaitAt !== null) {
          this.unexpected(awaitAt);
        }
        return this.parseFor(node2, init);
      }
      parseFunctionStatement(node2, isAsync, isHangingDeclaration) {
        this.next();
        return this.parseFunction(node2, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));
      }
      parseIfStatement(node2) {
        this.next();
        node2.test = this.parseHeaderExpression();
        node2.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
        node2.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
        return this.finishNode(node2, "IfStatement");
      }
      parseReturnStatement(node2) {
        if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
          this.raise(Errors.IllegalReturn, {
            at: this.state.startLoc
          });
        }
        this.next();
        if (this.isLineTerminator()) {
          node2.argument = null;
        } else {
          node2.argument = this.parseExpression();
          this.semicolon();
        }
        return this.finishNode(node2, "ReturnStatement");
      }
      parseSwitchStatement(node2) {
        this.next();
        node2.discriminant = this.parseHeaderExpression();
        const cases = node2.cases = [];
        this.expect(5);
        this.state.labels.push(switchLabel3);
        this.scope.enter(SCOPE_OTHER);
        let cur;
        for (let sawDefault; !this.match(8); ) {
          if (this.match(61) || this.match(65)) {
            const isCase = this.match(61);
            if (cur)
              this.finishNode(cur, "SwitchCase");
            cases.push(cur = this.startNode());
            cur.consequent = [];
            this.next();
            if (isCase) {
              cur.test = this.parseExpression();
            } else {
              if (sawDefault) {
                this.raise(Errors.MultipleDefaultsInSwitch, {
                  at: this.state.lastTokStartLoc
                });
              }
              sawDefault = true;
              cur.test = null;
            }
            this.expect(14);
          } else {
            if (cur) {
              cur.consequent.push(this.parseStatementListItem());
            } else {
              this.unexpected();
            }
          }
        }
        this.scope.exit();
        if (cur)
          this.finishNode(cur, "SwitchCase");
        this.next();
        this.state.labels.pop();
        return this.finishNode(node2, "SwitchStatement");
      }
      parseThrowStatement(node2) {
        this.next();
        if (this.hasPrecedingLineBreak()) {
          this.raise(Errors.NewlineAfterThrow, {
            at: this.state.lastTokEndLoc
          });
        }
        node2.argument = this.parseExpression();
        this.semicolon();
        return this.finishNode(node2, "ThrowStatement");
      }
      parseCatchClauseParam() {
        const param = this.parseBindingAtom();
        this.scope.enter(this.options.annexB && param.type === "Identifier" ? SCOPE_SIMPLE_CATCH3 : 0);
        this.checkLVal(param, {
          in: {
            type: "CatchClause"
          },
          binding: BIND_CATCH_PARAM
        });
        return param;
      }
      parseTryStatement(node2) {
        this.next();
        node2.block = this.parseBlock();
        node2.handler = null;
        if (this.match(62)) {
          const clause = this.startNode();
          this.next();
          if (this.match(10)) {
            this.expect(10);
            clause.param = this.parseCatchClauseParam();
            this.expect(11);
          } else {
            clause.param = null;
            this.scope.enter(SCOPE_OTHER);
          }
          clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));
          this.scope.exit();
          node2.handler = this.finishNode(clause, "CatchClause");
        }
        node2.finalizer = this.eat(67) ? this.parseBlock() : null;
        if (!node2.handler && !node2.finalizer) {
          this.raise(Errors.NoCatchOrFinally, {
            at: node2
          });
        }
        return this.finishNode(node2, "TryStatement");
      }
      parseVarStatement(node2, kind, allowMissingInitializer = false) {
        this.next();
        this.parseVar(node2, false, kind, allowMissingInitializer);
        this.semicolon();
        return this.finishNode(node2, "VariableDeclaration");
      }
      parseWhileStatement(node2) {
        this.next();
        node2.test = this.parseHeaderExpression();
        this.state.labels.push(loopLabel3);
        node2.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
        this.state.labels.pop();
        return this.finishNode(node2, "WhileStatement");
      }
      parseWithStatement(node2) {
        if (this.state.strict) {
          this.raise(Errors.StrictWith, {
            at: this.state.startLoc
          });
        }
        this.next();
        node2.object = this.parseHeaderExpression();
        node2.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
        return this.finishNode(node2, "WithStatement");
      }
      parseEmptyStatement(node2) {
        this.next();
        return this.finishNode(node2, "EmptyStatement");
      }
      parseLabeledStatement(node2, maybeName, expr, flags) {
        for (const label of this.state.labels) {
          if (label.name === maybeName) {
            this.raise(Errors.LabelRedeclaration, {
              at: expr,
              labelName: maybeName
            });
          }
        }
        const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null;
        for (let i = this.state.labels.length - 1; i >= 0; i--) {
          const label = this.state.labels[i];
          if (label.statementStart === node2.start) {
            label.statementStart = this.state.start;
            label.kind = kind;
          } else {
            break;
          }
        }
        this.state.labels.push({
          name: maybeName,
          kind,
          statementStart: this.state.start
        });
        node2.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
        this.state.labels.pop();
        node2.label = expr;
        return this.finishNode(node2, "LabeledStatement");
      }
      parseExpressionStatement(node2, expr, decorators) {
        node2.expression = expr;
        this.semicolon();
        return this.finishNode(node2, "ExpressionStatement");
      }
      parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {
        const node2 = this.startNode();
        if (allowDirectives) {
          this.state.strictErrors.clear();
        }
        this.expect(5);
        if (createNewLexicalScope) {
          this.scope.enter(SCOPE_OTHER);
        }
        this.parseBlockBody(node2, allowDirectives, false, 8, afterBlockParse);
        if (createNewLexicalScope) {
          this.scope.exit();
        }
        return this.finishNode(node2, "BlockStatement");
      }
      isValidDirective(stmt) {
        return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
      }
      parseBlockBody(node2, allowDirectives, topLevel, end, afterBlockParse) {
        const body = node2.body = [];
        const directives = node2.directives = [];
        this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : void 0, topLevel, end, afterBlockParse);
      }
      parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {
        const oldStrict = this.state.strict;
        let hasStrictModeDirective = false;
        let parsedNonDirective = false;
        while (!this.match(end)) {
          const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
          if (directives && !parsedNonDirective) {
            if (this.isValidDirective(stmt)) {
              const directive = this.stmtToDirective(stmt);
              directives.push(directive);
              if (!hasStrictModeDirective && directive.value.value === "use strict") {
                hasStrictModeDirective = true;
                this.setStrict(true);
              }
              continue;
            }
            parsedNonDirective = true;
            this.state.strictErrors.clear();
          }
          body.push(stmt);
        }
        if (afterBlockParse) {
          afterBlockParse.call(this, hasStrictModeDirective);
        }
        if (!oldStrict) {
          this.setStrict(false);
        }
        this.next();
      }
      parseFor(node2, init) {
        node2.init = init;
        this.semicolon(false);
        node2.test = this.match(13) ? null : this.parseExpression();
        this.semicolon(false);
        node2.update = this.match(11) ? null : this.parseExpression();
        this.expect(11);
        node2.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
        this.scope.exit();
        this.state.labels.pop();
        return this.finishNode(node2, "ForStatement");
      }
      parseForIn(node2, init, awaitAt) {
        const isForIn = this.match(58);
        this.next();
        if (isForIn) {
          if (awaitAt !== null)
            this.unexpected(awaitAt);
        } else {
          node2.await = awaitAt !== null;
        }
        if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
          this.raise(Errors.ForInOfLoopInitializer, {
            at: init,
            type: isForIn ? "ForInStatement" : "ForOfStatement"
          });
        }
        if (init.type === "AssignmentPattern") {
          this.raise(Errors.InvalidLhs, {
            at: init,
            ancestor: {
              type: "ForStatement"
            }
          });
        }
        node2.left = init;
        node2.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
        this.expect(11);
        node2.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
        this.scope.exit();
        this.state.labels.pop();
        return this.finishNode(node2, isForIn ? "ForInStatement" : "ForOfStatement");
      }
      parseVar(node2, isFor, kind, allowMissingInitializer = false) {
        const declarations = node2.declarations = [];
        node2.kind = kind;
        for (; ; ) {
          const decl = this.startNode();
          this.parseVarId(decl, kind);
          decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
          if (decl.init === null && !allowMissingInitializer) {
            if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) {
              this.raise(Errors.DeclarationMissingInitializer, {
                at: this.state.lastTokEndLoc,
                kind: "destructuring"
              });
            } else if (kind === "const" && !(this.match(58) || this.isContextual(101))) {
              this.raise(Errors.DeclarationMissingInitializer, {
                at: this.state.lastTokEndLoc,
                kind: "const"
              });
            }
          }
          declarations.push(this.finishNode(decl, "VariableDeclarator"));
          if (!this.eat(12))
            break;
        }
        return node2;
      }
      parseVarId(decl, kind) {
        if (kind === "using" && !this.inModule && this.match(96)) {
          this.raise(Errors.AwaitInUsingBinding, {
            at: this.state.startLoc
          });
        }
        const id = this.parseBindingAtom();
        this.checkLVal(id, {
          in: {
            type: "VariableDeclarator"
          },
          binding: kind === "var" ? BIND_VAR3 : BIND_LEXICAL3
        });
        decl.id = id;
      }
      parseAsyncFunctionExpression(node2) {
        return this.parseFunction(node2, 8);
      }
      parseFunction(node2, flags = 0) {
        const hangingDeclaration = flags & 2;
        const isDeclaration2 = !!(flags & 1);
        const requireId = isDeclaration2 && !(flags & 4);
        const isAsync = !!(flags & 8);
        this.initFunction(node2, isAsync);
        if (this.match(55)) {
          if (hangingDeclaration) {
            this.raise(Errors.GeneratorInSingleStatementContext, {
              at: this.state.startLoc
            });
          }
          this.next();
          node2.generator = true;
        }
        if (isDeclaration2) {
          node2.id = this.parseFunctionId(requireId);
        }
        const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
        this.state.maybeInArrowParameters = false;
        this.scope.enter(SCOPE_FUNCTION3);
        this.prodParam.enter(functionFlags3(isAsync, node2.generator));
        if (!isDeclaration2) {
          node2.id = this.parseFunctionId();
        }
        this.parseFunctionParams(node2, false);
        this.withSmartMixTopicForbiddingContext(() => {
          this.parseFunctionBodyAndFinish(node2, isDeclaration2 ? "FunctionDeclaration" : "FunctionExpression");
        });
        this.prodParam.exit();
        this.scope.exit();
        if (isDeclaration2 && !hangingDeclaration) {
          this.registerFunctionStatementId(node2);
        }
        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
        return node2;
      }
      parseFunctionId(requireId) {
        return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
      }
      parseFunctionParams(node2, isConstructor) {
        this.expect(10);
        this.expressionScope.enter(newParameterDeclarationScope());
        node2.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));
        this.expressionScope.exit();
      }
      registerFunctionStatementId(node2) {
        if (!node2.id)
          return;
        this.scope.declareName(node2.id.name, !this.options.annexB || this.state.strict || node2.generator || node2.async ? this.scope.treatFunctionsAsVar ? BIND_VAR3 : BIND_LEXICAL3 : BIND_FUNCTION3, node2.id.loc.start);
      }
      parseClass(node2, isStatement, optionalId) {
        this.next();
        const oldStrict = this.state.strict;
        this.state.strict = true;
        this.parseClassId(node2, isStatement, optionalId);
        this.parseClassSuper(node2);
        node2.body = this.parseClassBody(!!node2.superClass, oldStrict);
        return this.finishNode(node2, isStatement ? "ClassDeclaration" : "ClassExpression");
      }
      isClassProperty() {
        return this.match(29) || this.match(13) || this.match(8);
      }
      isClassMethod() {
        return this.match(10);
      }
      isNonstaticConstructor(method) {
        return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
      }
      parseClassBody(hadSuperClass, oldStrict) {
        this.classScope.enter();
        const state = {
          hadConstructor: false,
          hadSuperClass
        };
        let decorators = [];
        const classBody = this.startNode();
        classBody.body = [];
        this.expect(5);
        this.withSmartMixTopicForbiddingContext(() => {
          while (!this.match(8)) {
            if (this.eat(13)) {
              if (decorators.length > 0) {
                throw this.raise(Errors.DecoratorSemicolon, {
                  at: this.state.lastTokEndLoc
                });
              }
              continue;
            }
            if (this.match(26)) {
              decorators.push(this.parseDecorator());
              continue;
            }
            const member = this.startNode();
            if (decorators.length) {
              member.decorators = decorators;
              this.resetStartLocationFromNode(member, decorators[0]);
              decorators = [];
            }
            this.parseClassMember(classBody, member, state);
            if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
              this.raise(Errors.DecoratorConstructor, {
                at: member
              });
            }
          }
        });
        this.state.strict = oldStrict;
        this.next();
        if (decorators.length) {
          throw this.raise(Errors.TrailingDecorator, {
            at: this.state.startLoc
          });
        }
        this.classScope.exit();
        return this.finishNode(classBody, "ClassBody");
      }
      parseClassMemberFromModifier(classBody, member) {
        const key2 = this.parseIdentifier(true);
        if (this.isClassMethod()) {
          const method = member;
          method.kind = "method";
          method.computed = false;
          method.key = key2;
          method.static = false;
          this.pushClassMethod(classBody, method, false, false, false, false);
          return true;
        } else if (this.isClassProperty()) {
          const prop = member;
          prop.computed = false;
          prop.key = key2;
          prop.static = false;
          classBody.body.push(this.parseClassProperty(prop));
          return true;
        }
        this.resetPreviousNodeTrailingComments(key2);
        return false;
      }
      parseClassMember(classBody, member, state) {
        const isStatic = this.isContextual(104);
        if (isStatic) {
          if (this.parseClassMemberFromModifier(classBody, member)) {
            return;
          }
          if (this.eat(5)) {
            this.parseClassStaticBlock(classBody, member);
            return;
          }
        }
        this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
      }
      parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
        const publicMethod = member;
        const privateMethod = member;
        const publicProp = member;
        const privateProp = member;
        const accessorProp = member;
        const method = publicMethod;
        const publicMember = publicMethod;
        member.static = isStatic;
        this.parsePropertyNamePrefixOperator(member);
        if (this.eat(55)) {
          method.kind = "method";
          const isPrivateName = this.match(136);
          this.parseClassElementName(method);
          if (isPrivateName) {
            this.pushClassPrivateMethod(classBody, privateMethod, true, false);
            return;
          }
          if (this.isNonstaticConstructor(publicMethod)) {
            this.raise(Errors.ConstructorIsGenerator, {
              at: publicMethod.key
            });
          }
          this.pushClassMethod(classBody, publicMethod, true, false, false, false);
          return;
        }
        const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
        const isPrivate = this.match(136);
        const key2 = this.parseClassElementName(member);
        const maybeQuestionTokenStartLoc = this.state.startLoc;
        this.parsePostMemberNameModifiers(publicMember);
        if (this.isClassMethod()) {
          method.kind = "method";
          if (isPrivate) {
            this.pushClassPrivateMethod(classBody, privateMethod, false, false);
            return;
          }
          const isConstructor = this.isNonstaticConstructor(publicMethod);
          let allowsDirectSuper = false;
          if (isConstructor) {
            publicMethod.kind = "constructor";
            if (state.hadConstructor && !this.hasPlugin("typescript")) {
              this.raise(Errors.DuplicateConstructor, {
                at: key2
              });
            }
            if (isConstructor && this.hasPlugin("typescript") && member.override) {
              this.raise(Errors.OverrideOnConstructor, {
                at: key2
              });
            }
            state.hadConstructor = true;
            allowsDirectSuper = state.hadSuperClass;
          }
          this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
        } else if (this.isClassProperty()) {
          if (isPrivate) {
            this.pushClassPrivateProperty(classBody, privateProp);
          } else {
            this.pushClassProperty(classBody, publicProp);
          }
        } else if (isContextual && key2.name === "async" && !this.isLineTerminator()) {
          this.resetPreviousNodeTrailingComments(key2);
          const isGenerator = this.eat(55);
          if (publicMember.optional) {
            this.unexpected(maybeQuestionTokenStartLoc);
          }
          method.kind = "method";
          const isPrivate2 = this.match(136);
          this.parseClassElementName(method);
          this.parsePostMemberNameModifiers(publicMember);
          if (isPrivate2) {
            this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
          } else {
            if (this.isNonstaticConstructor(publicMethod)) {
              this.raise(Errors.ConstructorIsAsync, {
                at: publicMethod.key
              });
            }
            this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
          }
        } else if (isContextual && (key2.name === "get" || key2.name === "set") && !(this.match(55) && this.isLineTerminator())) {
          this.resetPreviousNodeTrailingComments(key2);
          method.kind = key2.name;
          const isPrivate2 = this.match(136);
          this.parseClassElementName(publicMethod);
          if (isPrivate2) {
            this.pushClassPrivateMethod(classBody, privateMethod, false, false);
          } else {
            if (this.isNonstaticConstructor(publicMethod)) {
              this.raise(Errors.ConstructorIsAccessor, {
                at: publicMethod.key
              });
            }
            this.pushClassMethod(classBody, publicMethod, false, false, false, false);
          }
          this.checkGetterSetterParams(publicMethod);
        } else if (isContextual && key2.name === "accessor" && !this.isLineTerminator()) {
          this.expectPlugin("decoratorAutoAccessors");
          this.resetPreviousNodeTrailingComments(key2);
          const isPrivate2 = this.match(136);
          this.parseClassElementName(publicProp);
          this.pushClassAccessorProperty(classBody, accessorProp, isPrivate2);
        } else if (this.isLineTerminator()) {
          if (isPrivate) {
            this.pushClassPrivateProperty(classBody, privateProp);
          } else {
            this.pushClassProperty(classBody, publicProp);
          }
        } else {
          this.unexpected();
        }
      }
      parseClassElementName(member) {
        const {
          type,
          value: value2
        } = this.state;
        if ((type === 130 || type === 131) && member.static && value2 === "prototype") {
          this.raise(Errors.StaticPrototype, {
            at: this.state.startLoc
          });
        }
        if (type === 136) {
          if (value2 === "constructor") {
            this.raise(Errors.ConstructorClassPrivateField, {
              at: this.state.startLoc
            });
          }
          const key2 = this.parsePrivateName();
          member.key = key2;
          return key2;
        }
        return this.parsePropertyName(member);
      }
      parseClassStaticBlock(classBody, member) {
        var _member$decorators;
        this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER3);
        const oldLabels = this.state.labels;
        this.state.labels = [];
        this.prodParam.enter(PARAM);
        const body = member.body = [];
        this.parseBlockOrModuleBlockBody(body, void 0, false, 8);
        this.prodParam.exit();
        this.scope.exit();
        this.state.labels = oldLabels;
        classBody.body.push(this.finishNode(member, "StaticBlock"));
        if ((_member$decorators = member.decorators) != null && _member$decorators.length) {
          this.raise(Errors.DecoratorStaticBlock, {
            at: member
          });
        }
      }
      pushClassProperty(classBody, prop) {
        if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
          this.raise(Errors.ConstructorClassField, {
            at: prop.key
          });
        }
        classBody.body.push(this.parseClassProperty(prop));
      }
      pushClassPrivateProperty(classBody, prop) {
        const node2 = this.parseClassPrivateProperty(prop);
        classBody.body.push(node2);
        this.classScope.declarePrivateName(this.getPrivateNameSV(node2.key), CLASS_ELEMENT_OTHER, node2.key.loc.start);
      }
      pushClassAccessorProperty(classBody, prop, isPrivate) {
        if (!isPrivate && !prop.computed) {
          const key2 = prop.key;
          if (key2.name === "constructor" || key2.value === "constructor") {
            this.raise(Errors.ConstructorClassField, {
              at: key2
            });
          }
        }
        const node2 = this.parseClassAccessorProperty(prop);
        classBody.body.push(node2);
        if (isPrivate) {
          this.classScope.declarePrivateName(this.getPrivateNameSV(node2.key), CLASS_ELEMENT_OTHER, node2.key.loc.start);
        }
      }
      pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
        classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
      }
      pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
        const node2 = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true);
        classBody.body.push(node2);
        const kind = node2.kind === "get" ? node2.static ? CLASS_ELEMENT_STATIC_GETTER : CLASS_ELEMENT_INSTANCE_GETTER : node2.kind === "set" ? node2.static ? CLASS_ELEMENT_STATIC_SETTER : CLASS_ELEMENT_INSTANCE_SETTER : CLASS_ELEMENT_OTHER;
        this.declareClassPrivateMethodInScope(node2, kind);
      }
      declareClassPrivateMethodInScope(node2, kind) {
        this.classScope.declarePrivateName(this.getPrivateNameSV(node2.key), kind, node2.key.loc.start);
      }
      parsePostMemberNameModifiers(methodOrProp) {
      }
      parseClassPrivateProperty(node2) {
        this.parseInitializer(node2);
        this.semicolon();
        return this.finishNode(node2, "ClassPrivateProperty");
      }
      parseClassProperty(node2) {
        this.parseInitializer(node2);
        this.semicolon();
        return this.finishNode(node2, "ClassProperty");
      }
      parseClassAccessorProperty(node2) {
        this.parseInitializer(node2);
        this.semicolon();
        return this.finishNode(node2, "ClassAccessorProperty");
      }
      parseInitializer(node2) {
        this.scope.enter(SCOPE_CLASS | SCOPE_SUPER3);
        this.expressionScope.enter(newExpressionScope());
        this.prodParam.enter(PARAM);
        node2.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
        this.expressionScope.exit();
        this.prodParam.exit();
        this.scope.exit();
      }
      parseClassId(node2, isStatement, optionalId, bindingType = BIND_CLASS) {
        if (tokenIsIdentifier(this.state.type)) {
          node2.id = this.parseIdentifier();
          if (isStatement) {
            this.declareNameFromIdentifier(node2.id, bindingType);
          }
        } else {
          if (optionalId || !isStatement) {
            node2.id = null;
          } else {
            throw this.raise(Errors.MissingClassName, {
              at: this.state.startLoc
            });
          }
        }
      }
      parseClassSuper(node2) {
        node2.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
      }
      parseExport(node2, decorators) {
        const hasDefault = this.maybeParseExportDefaultSpecifier(node2);
        const parseAfterDefault = !hasDefault || this.eat(12);
        const hasStar = parseAfterDefault && this.eatExportStar(node2);
        const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node2);
        const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));
        const isFromRequired = hasDefault || hasStar;
        if (hasStar && !hasNamespace) {
          if (hasDefault)
            this.unexpected();
          if (decorators) {
            throw this.raise(Errors.UnsupportedDecoratorExport, {
              at: node2
            });
          }
          this.parseExportFrom(node2, true);
          return this.finishNode(node2, "ExportAllDeclaration");
        }
        const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node2);
        if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
          this.unexpected(null, 5);
        }
        if (hasNamespace && parseAfterNamespace) {
          this.unexpected(null, 97);
        }
        let hasDeclaration;
        if (isFromRequired || hasSpecifiers) {
          hasDeclaration = false;
          if (decorators) {
            throw this.raise(Errors.UnsupportedDecoratorExport, {
              at: node2
            });
          }
          this.parseExportFrom(node2, isFromRequired);
        } else {
          hasDeclaration = this.maybeParseExportDeclaration(node2);
        }
        if (isFromRequired || hasSpecifiers || hasDeclaration) {
          var _node2$declaration;
          const node22 = node2;
          this.checkExport(node22, true, false, !!node22.source);
          if (((_node2$declaration = node22.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") {
            this.maybeTakeDecorators(decorators, node22.declaration, node22);
          } else if (decorators) {
            throw this.raise(Errors.UnsupportedDecoratorExport, {
              at: node2
            });
          }
          return this.finishNode(node22, "ExportNamedDeclaration");
        }
        if (this.eat(65)) {
          const node22 = node2;
          const decl = this.parseExportDefaultExpression();
          node22.declaration = decl;
          if (decl.type === "ClassDeclaration") {
            this.maybeTakeDecorators(decorators, decl, node22);
          } else if (decorators) {
            throw this.raise(Errors.UnsupportedDecoratorExport, {
              at: node2
            });
          }
          this.checkExport(node22, true, true);
          return this.finishNode(node22, "ExportDefaultDeclaration");
        }
        this.unexpected(null, 5);
      }
      eatExportStar(node2) {
        return this.eat(55);
      }
      maybeParseExportDefaultSpecifier(node2) {
        if (this.isExportDefaultSpecifier()) {
          this.expectPlugin("exportDefaultFrom");
          const specifier = this.startNode();
          specifier.exported = this.parseIdentifier(true);
          node2.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
          return true;
        }
        return false;
      }
      maybeParseExportNamespaceSpecifier(node2) {
        if (this.isContextual(93)) {
          if (!node2.specifiers)
            node2.specifiers = [];
          const specifier = this.startNodeAt(this.state.lastTokStartLoc);
          this.next();
          specifier.exported = this.parseModuleExportName();
          node2.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
          return true;
        }
        return false;
      }
      maybeParseExportNamedSpecifiers(node2) {
        if (this.match(5)) {
          if (!node2.specifiers)
            node2.specifiers = [];
          const isTypeExport = node2.exportKind === "type";
          node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
          node2.source = null;
          node2.declaration = null;
          if (this.hasPlugin("importAssertions")) {
            node2.assertions = [];
          }
          return true;
        }
        return false;
      }
      maybeParseExportDeclaration(node2) {
        if (this.shouldParseExportDeclaration()) {
          node2.specifiers = [];
          node2.source = null;
          if (this.hasPlugin("importAssertions")) {
            node2.assertions = [];
          }
          node2.declaration = this.parseExportDeclaration(node2);
          return true;
        }
        return false;
      }
      isAsyncFunction() {
        if (!this.isContextual(95))
          return false;
        const next = this.nextTokenStart();
        return !lineBreak3.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
      }
      parseExportDefaultExpression() {
        const expr = this.startNode();
        if (this.match(68)) {
          this.next();
          return this.parseFunction(expr, 1 | 4);
        } else if (this.isAsyncFunction()) {
          this.next();
          this.next();
          return this.parseFunction(expr, 1 | 4 | 8);
        }
        if (this.match(80)) {
          return this.parseClass(expr, true, true);
        }
        if (this.match(26)) {
          if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
            this.raise(Errors.DecoratorBeforeExport, {
              at: this.state.startLoc
            });
          }
          return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
        }
        if (this.match(75) || this.match(74) || this.isLet()) {
          throw this.raise(Errors.UnsupportedDefaultExport, {
            at: this.state.startLoc
          });
        }
        const res = this.parseMaybeAssignAllowIn();
        this.semicolon();
        return res;
      }
      parseExportDeclaration(node2) {
        if (this.match(80)) {
          const node3 = this.parseClass(this.startNode(), true, false);
          return node3;
        }
        return this.parseStatementListItem();
      }
      isExportDefaultSpecifier() {
        const {
          type
        } = this.state;
        if (tokenIsIdentifier(type)) {
          if (type === 95 && !this.state.containsEsc || type === 99) {
            return false;
          }
          if ((type === 128 || type === 127) && !this.state.containsEsc) {
            const {
              type: nextType
            } = this.lookahead();
            if (tokenIsIdentifier(nextType) && nextType !== 97 || nextType === 5) {
              this.expectOnePlugin(["flow", "typescript"]);
              return false;
            }
          }
        } else if (!this.match(65)) {
          return false;
        }
        const next = this.nextTokenStart();
        const hasFrom = this.isUnparsedContextual(next, "from");
        if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) {
          return true;
        }
        if (this.match(65) && hasFrom) {
          const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
          return nextAfterFrom === 34 || nextAfterFrom === 39;
        }
        return false;
      }
      parseExportFrom(node2, expect) {
        if (this.eatContextual(97)) {
          node2.source = this.parseImportSource();
          this.checkExport(node2);
          const assertions = this.maybeParseImportAssertions();
          if (assertions) {
            node2.assertions = assertions;
            this.checkJSONModuleImport(node2);
          }
        } else if (expect) {
          this.unexpected();
        }
        this.semicolon();
      }
      shouldParseExportDeclaration() {
        const {
          type
        } = this.state;
        if (type === 26) {
          this.expectOnePlugin(["decorators", "decorators-legacy"]);
          if (this.hasPlugin("decorators")) {
            if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
              this.raise(Errors.DecoratorBeforeExport, {
                at: this.state.startLoc
              });
            }
            return true;
          }
        }
        return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();
      }
      checkExport(node2, checkNames, isDefault, isFrom) {
        if (checkNames) {
          if (isDefault) {
            this.checkDuplicateExports(node2, "default");
            if (this.hasPlugin("exportDefaultFrom")) {
              var _declaration$extra;
              const declaration = node2.declaration;
              if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {
                this.raise(Errors.ExportDefaultFromAsIdentifier, {
                  at: declaration
                });
              }
            }
          } else if (node2.specifiers && node2.specifiers.length) {
            for (const specifier of node2.specifiers) {
              const {
                exported
              } = specifier;
              const exportName = exported.type === "Identifier" ? exported.name : exported.value;
              this.checkDuplicateExports(specifier, exportName);
              if (!isFrom && specifier.local) {
                const {
                  local
                } = specifier;
                if (local.type !== "Identifier") {
                  this.raise(Errors.ExportBindingIsString, {
                    at: specifier,
                    localName: local.value,
                    exportName
                  });
                } else {
                  this.checkReservedWord(local.name, local.loc.start, true, false);
                  this.scope.checkLocalExport(local);
                }
              }
            }
          } else if (node2.declaration) {
            if (node2.declaration.type === "FunctionDeclaration" || node2.declaration.type === "ClassDeclaration") {
              const id = node2.declaration.id;
              if (!id)
                throw new Error("Assertion failure");
              this.checkDuplicateExports(node2, id.name);
            } else if (node2.declaration.type === "VariableDeclaration") {
              for (const declaration of node2.declaration.declarations) {
                this.checkDeclaration(declaration.id);
              }
            }
          }
        }
      }
      checkDeclaration(node2) {
        if (node2.type === "Identifier") {
          this.checkDuplicateExports(node2, node2.name);
        } else if (node2.type === "ObjectPattern") {
          for (const prop of node2.properties) {
            this.checkDeclaration(prop);
          }
        } else if (node2.type === "ArrayPattern") {
          for (const elem of node2.elements) {
            if (elem) {
              this.checkDeclaration(elem);
            }
          }
        } else if (node2.type === "ObjectProperty") {
          this.checkDeclaration(node2.value);
        } else if (node2.type === "RestElement") {
          this.checkDeclaration(node2.argument);
        } else if (node2.type === "AssignmentPattern") {
          this.checkDeclaration(node2.left);
        }
      }
      checkDuplicateExports(node2, exportName) {
        if (this.exportedIdentifiers.has(exportName)) {
          if (exportName === "default") {
            this.raise(Errors.DuplicateDefaultExport, {
              at: node2
            });
          } else {
            this.raise(Errors.DuplicateExport, {
              at: node2,
              exportName
            });
          }
        }
        this.exportedIdentifiers.add(exportName);
      }
      parseExportSpecifiers(isInTypeExport) {
        const nodes = [];
        let first = true;
        this.expect(5);
        while (!this.eat(8)) {
          if (first) {
            first = false;
          } else {
            this.expect(12);
            if (this.eat(8))
              break;
          }
          const isMaybeTypeOnly = this.isContextual(128);
          const isString = this.match(131);
          const node2 = this.startNode();
          node2.local = this.parseModuleExportName();
          nodes.push(this.parseExportSpecifier(node2, isString, isInTypeExport, isMaybeTypeOnly));
        }
        return nodes;
      }
      parseExportSpecifier(node2, isString, isInTypeExport, isMaybeTypeOnly) {
        if (this.eatContextual(93)) {
          node2.exported = this.parseModuleExportName();
        } else if (isString) {
          node2.exported = cloneStringLiteral(node2.local);
        } else if (!node2.exported) {
          node2.exported = cloneIdentifier(node2.local);
        }
        return this.finishNode(node2, "ExportSpecifier");
      }
      parseModuleExportName() {
        if (this.match(131)) {
          const result = this.parseStringLiteral(this.state.value);
          const surrogate = result.value.match(loneSurrogate2);
          if (surrogate) {
            this.raise(Errors.ModuleExportNameHasLoneSurrogate, {
              at: result,
              surrogateCharCode: surrogate[0].charCodeAt(0)
            });
          }
          return result;
        }
        return this.parseIdentifier(true);
      }
      isJSONModuleImport(node2) {
        if (node2.assertions != null) {
          return node2.assertions.some(({
            key: key2,
            value: value2
          }) => {
            return value2.value === "json" && (key2.type === "Identifier" ? key2.name === "type" : key2.value === "type");
          });
        }
        return false;
      }
      checkImportReflection(node2) {
        if (node2.module) {
          var _node$assertions;
          if (node2.specifiers.length !== 1 || node2.specifiers[0].type !== "ImportDefaultSpecifier") {
            this.raise(Errors.ImportReflectionNotBinding, {
              at: node2.specifiers[0].loc.start
            });
          }
          if (((_node$assertions = node2.assertions) == null ? void 0 : _node$assertions.length) > 0) {
            this.raise(Errors.ImportReflectionHasAssertion, {
              at: node2.specifiers[0].loc.start
            });
          }
        }
      }
      checkJSONModuleImport(node2) {
        if (this.isJSONModuleImport(node2) && node2.type !== "ExportAllDeclaration") {
          const {
            specifiers
          } = node2;
          if (specifiers != null) {
            const nonDefaultNamedSpecifier = specifiers.find((specifier) => {
              let imported;
              if (specifier.type === "ExportSpecifier") {
                imported = specifier.local;
              } else if (specifier.type === "ImportSpecifier") {
                imported = specifier.imported;
              }
              if (imported !== void 0) {
                return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
              }
            });
            if (nonDefaultNamedSpecifier !== void 0) {
              this.raise(Errors.ImportJSONBindingNotDefault, {
                at: nonDefaultNamedSpecifier.loc.start
              });
            }
          }
        }
      }
      parseMaybeImportReflection(node2) {
        let isImportReflection = false;
        if (this.isContextual(125)) {
          const lookahead3 = this.lookahead();
          const nextType = lookahead3.type;
          if (tokenIsIdentifier(nextType)) {
            if (nextType !== 97) {
              isImportReflection = true;
            } else {
              const nextNextTokenFirstChar = this.input.charCodeAt(this.nextTokenStartSince(lookahead3.end));
              if (nextNextTokenFirstChar === 102) {
                isImportReflection = true;
              }
            }
          } else if (nextType !== 12) {
            isImportReflection = true;
          }
        }
        if (isImportReflection) {
          this.expectPlugin("importReflection");
          this.next();
          node2.module = true;
        } else if (this.hasPlugin("importReflection")) {
          node2.module = false;
        }
      }
      parseImport(node2) {
        node2.specifiers = [];
        if (!this.match(131)) {
          this.parseMaybeImportReflection(node2);
          const hasDefault = this.maybeParseDefaultImportSpecifier(node2);
          const parseNext = !hasDefault || this.eat(12);
          const hasStar = parseNext && this.maybeParseStarImportSpecifier(node2);
          if (parseNext && !hasStar)
            this.parseNamedImportSpecifiers(node2);
          this.expectContextual(97);
        }
        node2.source = this.parseImportSource();
        const assertions = this.maybeParseImportAssertions();
        if (assertions) {
          node2.assertions = assertions;
        } else {
          const attributes = this.maybeParseModuleAttributes();
          if (attributes) {
            node2.attributes = attributes;
          }
        }
        this.checkImportReflection(node2);
        this.checkJSONModuleImport(node2);
        this.semicolon();
        return this.finishNode(node2, "ImportDeclaration");
      }
      parseImportSource() {
        if (!this.match(131))
          this.unexpected();
        return this.parseExprAtom();
      }
      shouldParseDefaultImport(node2) {
        return tokenIsIdentifier(this.state.type);
      }
      parseImportSpecifierLocal(node2, specifier, type) {
        specifier.local = this.parseIdentifier();
        node2.specifiers.push(this.finishImportSpecifier(specifier, type));
      }
      finishImportSpecifier(specifier, type, bindingType = BIND_LEXICAL3) {
        this.checkLVal(specifier.local, {
          in: {
            type
          },
          binding: bindingType
        });
        return this.finishNode(specifier, type);
      }
      parseAssertEntries() {
        const attrs = [];
        const attrNames = /* @__PURE__ */ new Set();
        do {
          if (this.match(8)) {
            break;
          }
          const node2 = this.startNode();
          const keyName = this.state.value;
          if (attrNames.has(keyName)) {
            this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
              at: this.state.startLoc,
              key: keyName
            });
          }
          attrNames.add(keyName);
          if (this.match(131)) {
            node2.key = this.parseStringLiteral(keyName);
          } else {
            node2.key = this.parseIdentifier(true);
          }
          this.expect(14);
          if (!this.match(131)) {
            throw this.raise(Errors.ModuleAttributeInvalidValue, {
              at: this.state.startLoc
            });
          }
          node2.value = this.parseStringLiteral(this.state.value);
          attrs.push(this.finishNode(node2, "ImportAttribute"));
        } while (this.eat(12));
        return attrs;
      }
      maybeParseModuleAttributes() {
        if (this.match(76) && !this.hasPrecedingLineBreak()) {
          this.expectPlugin("moduleAttributes");
          this.next();
        } else {
          if (this.hasPlugin("moduleAttributes"))
            return [];
          return null;
        }
        const attrs = [];
        const attributes = /* @__PURE__ */ new Set();
        do {
          const node2 = this.startNode();
          node2.key = this.parseIdentifier(true);
          if (node2.key.name !== "type") {
            this.raise(Errors.ModuleAttributeDifferentFromType, {
              at: node2.key
            });
          }
          if (attributes.has(node2.key.name)) {
            this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
              at: node2.key,
              key: node2.key.name
            });
          }
          attributes.add(node2.key.name);
          this.expect(14);
          if (!this.match(131)) {
            throw this.raise(Errors.ModuleAttributeInvalidValue, {
              at: this.state.startLoc
            });
          }
          node2.value = this.parseStringLiteral(this.state.value);
          this.finishNode(node2, "ImportAttribute");
          attrs.push(node2);
        } while (this.eat(12));
        return attrs;
      }
      maybeParseImportAssertions() {
        if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
          this.expectPlugin("importAssertions");
          this.next();
        } else {
          if (this.hasPlugin("importAssertions"))
            return [];
          return null;
        }
        this.eat(5);
        const attrs = this.parseAssertEntries();
        this.eat(8);
        return attrs;
      }
      maybeParseDefaultImportSpecifier(node2) {
        if (this.shouldParseDefaultImport(node2)) {
          this.parseImportSpecifierLocal(node2, this.startNode(), "ImportDefaultSpecifier");
          return true;
        }
        return false;
      }
      maybeParseStarImportSpecifier(node2) {
        if (this.match(55)) {
          const specifier = this.startNode();
          this.next();
          this.expectContextual(93);
          this.parseImportSpecifierLocal(node2, specifier, "ImportNamespaceSpecifier");
          return true;
        }
        return false;
      }
      parseNamedImportSpecifiers(node2) {
        let first = true;
        this.expect(5);
        while (!this.eat(8)) {
          if (first) {
            first = false;
          } else {
            if (this.eat(14)) {
              throw this.raise(Errors.DestructureNamedImport, {
                at: this.state.startLoc
              });
            }
            this.expect(12);
            if (this.eat(8))
              break;
          }
          const specifier = this.startNode();
          const importedIsString = this.match(131);
          const isMaybeTypeOnly = this.isContextual(128);
          specifier.imported = this.parseModuleExportName();
          const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node2.importKind === "type" || node2.importKind === "typeof", isMaybeTypeOnly, void 0);
          node2.specifiers.push(importSpecifier);
        }
      }
      parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
        if (this.eatContextual(93)) {
          specifier.local = this.parseIdentifier();
        } else {
          const {
            imported
          } = specifier;
          if (importedIsString) {
            throw this.raise(Errors.ImportBindingIsString, {
              at: specifier,
              importName: imported.value
            });
          }
          this.checkReservedWord(imported.name, specifier.loc.start, true, true);
          if (!specifier.local) {
            specifier.local = cloneIdentifier(imported);
          }
        }
        return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
      }
      isThisParam(param) {
        return param.type === "Identifier" && param.name === "this";
      }
    };
    var Parser5 = class extends StatementParser {
      constructor(options, input) {
        options = getOptions3(options);
        super(options, input);
        this.options = options;
        this.initializeScopes();
        this.plugins = pluginsMap(this.options.plugins);
        this.filename = options.sourceFilename;
      }
      getScopeHandler() {
        return ScopeHandler;
      }
      parse() {
        this.enterInitialScopes();
        const file = this.startNode();
        const program = this.startNode();
        this.nextToken();
        file.errors = null;
        this.parseTopLevel(file, program);
        file.errors = this.state.errors;
        return file;
      }
    };
    function pluginsMap(plugins) {
      const pluginMap = /* @__PURE__ */ new Map();
      for (const plugin2 of plugins) {
        const [name2, options] = Array.isArray(plugin2) ? plugin2 : [plugin2, {}];
        if (!pluginMap.has(name2))
          pluginMap.set(name2, options || {});
      }
      return pluginMap;
    }
    function parse9(input, options) {
      var _options;
      if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
        options = Object.assign({}, options);
        try {
          options.sourceType = "module";
          const parser = getParser(options, input);
          const ast = parser.parse();
          if (parser.sawUnambiguousESM) {
            return ast;
          }
          if (parser.ambiguousScriptDifferentAst) {
            try {
              options.sourceType = "script";
              return getParser(options, input).parse();
            } catch (_unused) {
            }
          } else {
            ast.program.sourceType = "script";
          }
          return ast;
        } catch (moduleError) {
          try {
            options.sourceType = "script";
            return getParser(options, input).parse();
          } catch (_unused2) {
          }
          throw moduleError;
        }
      } else {
        return getParser(options, input).parse();
      }
    }
    function parseExpression(input, options) {
      const parser = getParser(options, input);
      if (parser.options.strictMode) {
        parser.state.strict = true;
      }
      return parser.getExpression();
    }
    function generateExportedTokenTypes(internalTokenTypes) {
      const tokenTypes2 = {};
      for (const typeName of Object.keys(internalTokenTypes)) {
        tokenTypes2[typeName] = getExportedToken(internalTokenTypes[typeName]);
      }
      return tokenTypes2;
    }
    var tokTypes = generateExportedTokenTypes(tt);
    function getParser(options, input) {
      let cls = Parser5;
      if (options != null && options.plugins) {
        validatePlugins(options.plugins);
        cls = getParserClass(options.plugins);
      }
      return new cls(options, input);
    }
    var parserClassCache = {};
    function getParserClass(pluginsFromOptions) {
      const pluginList = mixinPluginNames.filter((name2) => hasPlugin(pluginsFromOptions, name2));
      const key2 = pluginList.join("/");
      let cls = parserClassCache[key2];
      if (!cls) {
        cls = Parser5;
        for (const plugin2 of pluginList) {
          cls = mixinPlugins[plugin2](cls);
        }
        parserClassCache[key2] = cls;
      }
      return cls;
    }
    exports.parse = parse9;
    exports.parseExpression = parseExpression;
    exports.tokTypes = tokTypes;
  }
});

// node_modules/@babel/helper-hoist-variables/lib/index.js
var require_lib10 = __commonJS({
  "node_modules/@babel/helper-hoist-variables/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = hoistVariables;
    var _t = require_lib3();
    var {
      assignmentExpression,
      expressionStatement,
      identifier
    } = _t;
    var visitor = {
      Scope(path, state) {
        if (state.kind === "let")
          path.skip();
      },
      FunctionParent(path) {
        path.skip();
      },
      VariableDeclaration(path, state) {
        if (state.kind && path.node.kind !== state.kind)
          return;
        const nodes = [];
        const declarations = path.get("declarations");
        let firstId;
        for (const declar of declarations) {
          firstId = declar.node.id;
          if (declar.node.init) {
            nodes.push(expressionStatement(assignmentExpression("=", declar.node.id, declar.node.init)));
          }
          for (const name2 of Object.keys(declar.getBindingIdentifiers())) {
            state.emit(identifier(name2), name2, declar.node.init !== null);
          }
        }
        if (path.parentPath.isFor({
          left: path.node
        })) {
          path.replaceWith(firstId);
        } else {
          path.replaceWithMultiple(nodes);
        }
      }
    };
    function hoistVariables(path, emit, kind = "var") {
      path.traverse(visitor, {
        kind,
        emit
      });
    }
  }
});

// node_modules/@babel/traverse/lib/path/replacement.js
var require_replacement = __commonJS({
  "node_modules/@babel/traverse/lib/path/replacement.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._replaceWith = _replaceWith;
    exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
    exports.replaceInline = replaceInline;
    exports.replaceWith = replaceWith;
    exports.replaceWithMultiple = replaceWithMultiple;
    exports.replaceWithSourceString = replaceWithSourceString;
    var _codeFrame = require_lib8();
    var _index = require_lib13();
    var _index2 = require_path();
    var _cache = require_cache();
    var _parser = require_lib9();
    var _t = require_lib3();
    var _helperHoistVariables = require_lib10();
    var {
      FUNCTION_TYPES,
      arrowFunctionExpression,
      assignmentExpression,
      awaitExpression,
      blockStatement,
      callExpression,
      cloneNode,
      expressionStatement,
      identifier,
      inheritLeadingComments,
      inheritTrailingComments,
      inheritsComments,
      isExpression,
      isProgram,
      isStatement,
      removeComments,
      returnStatement,
      toSequenceExpression,
      validate,
      yieldExpression
    } = _t;
    function replaceWithMultiple(nodes) {
      var _pathCache$get;
      this.resync();
      nodes = this._verifyNodeList(nodes);
      inheritLeadingComments(nodes[0], this.node);
      inheritTrailingComments(nodes[nodes.length - 1], this.node);
      (_pathCache$get = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get.delete(this.node);
      this.node = this.container[this.key] = null;
      const paths = this.insertAfter(nodes);
      if (this.node) {
        this.requeue();
      } else {
        this.remove();
      }
      return paths;
    }
    function replaceWithSourceString(replacement) {
      this.resync();
      let ast;
      try {
        replacement = `(${replacement})`;
        ast = (0, _parser.parse)(replacement);
      } catch (err) {
        const loc = err.loc;
        if (loc) {
          err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
            start: {
              line: loc.line,
              column: loc.column + 1
            }
          });
          err.code = "BABEL_REPLACE_SOURCE_ERROR";
        }
        throw err;
      }
      const expressionAST = ast.program.body[0].expression;
      _index.default.removeProperties(expressionAST);
      return this.replaceWith(expressionAST);
    }
    function replaceWith(replacementPath) {
      this.resync();
      if (this.removed) {
        throw new Error("You can't replace this node, we've already removed it");
      }
      let replacement = replacementPath instanceof _index2.default ? replacementPath.node : replacementPath;
      if (!replacement) {
        throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
      }
      if (this.node === replacement) {
        return [this];
      }
      if (this.isProgram() && !isProgram(replacement)) {
        throw new Error("You can only replace a Program root node with another Program node");
      }
      if (Array.isArray(replacement)) {
        throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
      }
      if (typeof replacement === "string") {
        throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
      }
      let nodePath = "";
      if (this.isNodeType("Statement") && isExpression(replacement)) {
        if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
          replacement = expressionStatement(replacement);
          nodePath = "expression";
        }
      }
      if (this.isNodeType("Expression") && isStatement(replacement)) {
        if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
          return this.replaceExpressionWithStatements([replacement]);
        }
      }
      const oldNode = this.node;
      if (oldNode) {
        inheritsComments(replacement, oldNode);
        removeComments(oldNode);
      }
      this._replaceWith(replacement);
      this.type = replacement.type;
      this.setScope();
      this.requeue();
      return [nodePath ? this.get(nodePath) : this];
    }
    function _replaceWith(node2) {
      var _pathCache$get2;
      if (!this.container) {
        throw new ReferenceError("Container is falsy");
      }
      if (this.inList) {
        validate(this.parent, this.key, [node2]);
      } else {
        validate(this.parent, this.key, node2);
      }
      this.debug(`Replace with ${node2 == null ? void 0 : node2.type}`);
      (_pathCache$get2 = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get2.set(node2, this).delete(this.node);
      this.node = this.container[this.key] = node2;
    }
    function replaceExpressionWithStatements(nodes) {
      this.resync();
      const nodesAsSequenceExpression = toSequenceExpression(nodes, this.scope);
      if (nodesAsSequenceExpression) {
        return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions");
      }
      const functionParent = this.getFunctionParent();
      const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
      const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator");
      const container = arrowFunctionExpression([], blockStatement(nodes));
      this.replaceWith(callExpression(container, []));
      const callee = this.get("callee");
      (0, _helperHoistVariables.default)(callee.get("body"), (id) => {
        this.scope.push({
          id
        });
      }, "var");
      const completionRecords = this.get("callee").getCompletionRecords();
      for (const path of completionRecords) {
        if (!path.isExpressionStatement())
          continue;
        const loop = path.findParent((path2) => path2.isLoop());
        if (loop) {
          let uid = loop.getData("expressionReplacementReturnUid");
          if (!uid) {
            uid = callee.scope.generateDeclaredUidIdentifier("ret");
            callee.get("body").pushContainer("body", returnStatement(cloneNode(uid)));
            loop.setData("expressionReplacementReturnUid", uid);
          } else {
            uid = identifier(uid.name);
          }
          path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression));
        } else {
          path.replaceWith(returnStatement(path.node.expression));
        }
      }
      callee.arrowFunctionToExpression();
      const newCallee = callee;
      const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", FUNCTION_TYPES);
      const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", FUNCTION_TYPES);
      if (needToAwaitFunction) {
        newCallee.set("async", true);
        if (!needToYieldFunction) {
          this.replaceWith(awaitExpression(this.node));
        }
      }
      if (needToYieldFunction) {
        newCallee.set("generator", true);
        this.replaceWith(yieldExpression(this.node, true));
      }
      return newCallee.get("body.body");
    }
    function replaceInline(nodes) {
      this.resync();
      if (Array.isArray(nodes)) {
        if (Array.isArray(this.container)) {
          nodes = this._verifyNodeList(nodes);
          const paths = this._containerInsertAfter(nodes);
          this.remove();
          return paths;
        } else {
          return this.replaceWithMultiple(nodes);
        }
      } else {
        return this.replaceWith(nodes);
      }
    }
  }
});

// node_modules/@babel/traverse/lib/path/evaluation.js
var require_evaluation = __commonJS({
  "node_modules/@babel/traverse/lib/path/evaluation.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.evaluate = evaluate;
    exports.evaluateTruthy = evaluateTruthy;
    var VALID_CALLEES = ["String", "Number", "Math"];
    var INVALID_METHODS = ["random"];
    function isValidCallee(val) {
      return VALID_CALLEES.includes(val);
    }
    function isInvalidMethod(val) {
      return INVALID_METHODS.includes(val);
    }
    function evaluateTruthy() {
      const res = this.evaluate();
      if (res.confident)
        return !!res.value;
    }
    function deopt(path, state) {
      if (!state.confident)
        return;
      state.deoptPath = path;
      state.confident = false;
    }
    var Globals = /* @__PURE__ */ new Map([["undefined", void 0], ["Infinity", Infinity], ["NaN", NaN]]);
    function evaluateCached(path, state) {
      const {
        node: node2
      } = path;
      const {
        seen
      } = state;
      if (seen.has(node2)) {
        const existing = seen.get(node2);
        if (existing.resolved) {
          return existing.value;
        } else {
          deopt(path, state);
          return;
        }
      } else {
        const item = {
          resolved: false
        };
        seen.set(node2, item);
        const val = _evaluate(path, state);
        if (state.confident) {
          item.resolved = true;
          item.value = val;
        }
        return val;
      }
    }
    function _evaluate(path, state) {
      if (!state.confident)
        return;
      if (path.isSequenceExpression()) {
        const exprs = path.get("expressions");
        return evaluateCached(exprs[exprs.length - 1], state);
      }
      if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
        return path.node.value;
      }
      if (path.isNullLiteral()) {
        return null;
      }
      if (path.isTemplateLiteral()) {
        return evaluateQuasis(path, path.node.quasis, state);
      }
      if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
        const object = path.get("tag.object");
        const {
          node: {
            name: name2
          }
        } = object;
        const property = path.get("tag.property");
        if (object.isIdentifier() && name2 === "String" && !path.scope.getBinding(name2) && property.isIdentifier() && property.node.name === "raw") {
          return evaluateQuasis(path, path.node.quasi.quasis, state, true);
        }
      }
      if (path.isConditionalExpression()) {
        const testResult = evaluateCached(path.get("test"), state);
        if (!state.confident)
          return;
        if (testResult) {
          return evaluateCached(path.get("consequent"), state);
        } else {
          return evaluateCached(path.get("alternate"), state);
        }
      }
      if (path.isExpressionWrapper()) {
        return evaluateCached(path.get("expression"), state);
      }
      if (path.isMemberExpression() && !path.parentPath.isCallExpression({
        callee: path.node
      })) {
        const property = path.get("property");
        const object = path.get("object");
        if (object.isLiteral()) {
          const value2 = object.node.value;
          const type = typeof value2;
          let key2 = null;
          if (path.node.computed) {
            key2 = evaluateCached(property, state);
            if (!state.confident)
              return;
          } else if (property.isIdentifier()) {
            key2 = property.node.name;
          }
          if ((type === "number" || type === "string") && key2 != null && (typeof key2 === "number" || typeof key2 === "string")) {
            return value2[key2];
          }
        }
      }
      if (path.isReferencedIdentifier()) {
        const binding = path.scope.getBinding(path.node.name);
        if (binding) {
          if (binding.constantViolations.length > 0 || path.node.start < binding.path.node.end) {
            deopt(binding.path, state);
            return;
          }
          if (binding.hasValue) {
            return binding.value;
          }
        }
        const name2 = path.node.name;
        if (Globals.has(name2)) {
          if (!binding) {
            return Globals.get(name2);
          }
          deopt(binding.path, state);
          return;
        }
        const resolved = path.resolve();
        if (resolved === path) {
          deopt(path, state);
          return;
        } else {
          return evaluateCached(resolved, state);
        }
      }
      if (path.isUnaryExpression({
        prefix: true
      })) {
        if (path.node.operator === "void") {
          return void 0;
        }
        const argument = path.get("argument");
        if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
          return "function";
        }
        const arg = evaluateCached(argument, state);
        if (!state.confident)
          return;
        switch (path.node.operator) {
          case "!":
            return !arg;
          case "+":
            return +arg;
          case "-":
            return -arg;
          case "~":
            return ~arg;
          case "typeof":
            return typeof arg;
        }
      }
      if (path.isArrayExpression()) {
        const arr = [];
        const elems = path.get("elements");
        for (const elem of elems) {
          const elemValue = elem.evaluate();
          if (elemValue.confident) {
            arr.push(elemValue.value);
          } else {
            deopt(elemValue.deopt, state);
            return;
          }
        }
        return arr;
      }
      if (path.isObjectExpression()) {
        const obj = {};
        const props = path.get("properties");
        for (const prop of props) {
          if (prop.isObjectMethod() || prop.isSpreadElement()) {
            deopt(prop, state);
            return;
          }
          const keyPath = prop.get("key");
          let key2;
          if (prop.node.computed) {
            key2 = keyPath.evaluate();
            if (!key2.confident) {
              deopt(key2.deopt, state);
              return;
            }
            key2 = key2.value;
          } else if (keyPath.isIdentifier()) {
            key2 = keyPath.node.name;
          } else {
            key2 = keyPath.node.value;
          }
          const valuePath = prop.get("value");
          let value2 = valuePath.evaluate();
          if (!value2.confident) {
            deopt(value2.deopt, state);
            return;
          }
          value2 = value2.value;
          obj[key2] = value2;
        }
        return obj;
      }
      if (path.isLogicalExpression()) {
        const wasConfident = state.confident;
        const left = evaluateCached(path.get("left"), state);
        const leftConfident = state.confident;
        state.confident = wasConfident;
        const right = evaluateCached(path.get("right"), state);
        const rightConfident = state.confident;
        switch (path.node.operator) {
          case "||":
            state.confident = leftConfident && (!!left || rightConfident);
            if (!state.confident)
              return;
            return left || right;
          case "&&":
            state.confident = leftConfident && (!left || rightConfident);
            if (!state.confident)
              return;
            return left && right;
          case "??":
            state.confident = leftConfident && (left != null || rightConfident);
            if (!state.confident)
              return;
            return left != null ? left : right;
        }
      }
      if (path.isBinaryExpression()) {
        const left = evaluateCached(path.get("left"), state);
        if (!state.confident)
          return;
        const right = evaluateCached(path.get("right"), state);
        if (!state.confident)
          return;
        switch (path.node.operator) {
          case "-":
            return left - right;
          case "+":
            return left + right;
          case "/":
            return left / right;
          case "*":
            return left * right;
          case "%":
            return left % right;
          case "**":
            return Math.pow(left, right);
          case "<":
            return left < right;
          case ">":
            return left > right;
          case "<=":
            return left <= right;
          case ">=":
            return left >= right;
          case "==":
            return left == right;
          case "!=":
            return left != right;
          case "===":
            return left === right;
          case "!==":
            return left !== right;
          case "|":
            return left | right;
          case "&":
            return left & right;
          case "^":
            return left ^ right;
          case "<<":
            return left << right;
          case ">>":
            return left >> right;
          case ">>>":
            return left >>> right;
        }
      }
      if (path.isCallExpression()) {
        const callee = path.get("callee");
        let context;
        let func;
        if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
          func = global[callee.node.name];
        }
        if (callee.isMemberExpression()) {
          const object = callee.get("object");
          const property = callee.get("property");
          if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
            context = global[object.node.name];
            func = context[property.node.name];
          }
          if (object.isLiteral() && property.isIdentifier()) {
            const type = typeof object.node.value;
            if (type === "string" || type === "number") {
              context = object.node.value;
              func = context[property.node.name];
            }
          }
        }
        if (func) {
          const args = path.get("arguments").map((arg) => evaluateCached(arg, state));
          if (!state.confident)
            return;
          return func.apply(context, args);
        }
      }
      deopt(path, state);
    }
    function evaluateQuasis(path, quasis, state, raw = false) {
      let str = "";
      let i = 0;
      const exprs = path.isTemplateLiteral() ? path.get("expressions") : path.get("quasi.expressions");
      for (const elem of quasis) {
        if (!state.confident)
          break;
        str += raw ? elem.value.raw : elem.value.cooked;
        const expr = exprs[i++];
        if (expr)
          str += String(evaluateCached(expr, state));
      }
      if (!state.confident)
        return;
      return str;
    }
    function evaluate() {
      const state = {
        confident: true,
        deoptPath: null,
        seen: /* @__PURE__ */ new Map()
      };
      let value2 = evaluateCached(this, state);
      if (!state.confident)
        value2 = void 0;
      return {
        confident: state.confident,
        deopt: state.deoptPath,
        value: value2
      };
    }
  }
});

// node_modules/@babel/template/lib/formatters.js
var require_formatters = __commonJS({
  "node_modules/@babel/template/lib/formatters.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.statements = exports.statement = exports.smart = exports.program = exports.expression = void 0;
    var _t = require_lib3();
    var {
      assertExpressionStatement
    } = _t;
    function makeStatementFormatter(fn) {
      return {
        code: (str) => `/* @babel/template */;
${str}`,
        validate: () => {
        },
        unwrap: (ast) => {
          return fn(ast.program.body.slice(1));
        }
      };
    }
    var smart = makeStatementFormatter((body) => {
      if (body.length > 1) {
        return body;
      } else {
        return body[0];
      }
    });
    exports.smart = smart;
    var statements = makeStatementFormatter((body) => body);
    exports.statements = statements;
    var statement = makeStatementFormatter((body) => {
      if (body.length === 0) {
        throw new Error("Found nothing to return.");
      }
      if (body.length > 1) {
        throw new Error("Found multiple statements but wanted one");
      }
      return body[0];
    });
    exports.statement = statement;
    var expression = {
      code: (str) => `(
${str}
)`,
      validate: (ast) => {
        if (ast.program.body.length > 1) {
          throw new Error("Found multiple statements but wanted one");
        }
        if (expression.unwrap(ast).start === 0) {
          throw new Error("Parse result included parens.");
        }
      },
      unwrap: ({
        program: program2
      }) => {
        const [stmt] = program2.body;
        assertExpressionStatement(stmt);
        return stmt.expression;
      }
    };
    exports.expression = expression;
    var program = {
      code: (str) => str,
      validate: () => {
      },
      unwrap: (ast) => ast.program
    };
    exports.program = program;
  }
});

// node_modules/@babel/template/lib/options.js
var require_options = __commonJS({
  "node_modules/@babel/template/lib/options.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.merge = merge2;
    exports.normalizeReplacements = normalizeReplacements;
    exports.validate = validate;
    var _excluded = ["placeholderWhitelist", "placeholderPattern", "preserveComments", "syntacticPlaceholders"];
    function _objectWithoutPropertiesLoose(source2, excluded) {
      if (source2 == null)
        return {};
      var target = {};
      var sourceKeys = Object.keys(source2);
      var key2, i;
      for (i = 0; i < sourceKeys.length; i++) {
        key2 = sourceKeys[i];
        if (excluded.indexOf(key2) >= 0)
          continue;
        target[key2] = source2[key2];
      }
      return target;
    }
    function merge2(a, b) {
      const {
        placeholderWhitelist = a.placeholderWhitelist,
        placeholderPattern = a.placeholderPattern,
        preserveComments = a.preserveComments,
        syntacticPlaceholders = a.syntacticPlaceholders
      } = b;
      return {
        parser: Object.assign({}, a.parser, b.parser),
        placeholderWhitelist,
        placeholderPattern,
        preserveComments,
        syntacticPlaceholders
      };
    }
    function validate(opts) {
      if (opts != null && typeof opts !== "object") {
        throw new Error("Unknown template options.");
      }
      const _ref = opts || {}, {
        placeholderWhitelist,
        placeholderPattern,
        preserveComments,
        syntacticPlaceholders
      } = _ref, parser = _objectWithoutPropertiesLoose(_ref, _excluded);
      if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
        throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined");
      }
      if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) {
        throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined");
      }
      if (preserveComments != null && typeof preserveComments !== "boolean") {
        throw new Error("'.preserveComments' must be a boolean, null, or undefined");
      }
      if (syntacticPlaceholders != null && typeof syntacticPlaceholders !== "boolean") {
        throw new Error("'.syntacticPlaceholders' must be a boolean, null, or undefined");
      }
      if (syntacticPlaceholders === true && (placeholderWhitelist != null || placeholderPattern != null)) {
        throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible with '.syntacticPlaceholders: true'");
      }
      return {
        parser,
        placeholderWhitelist: placeholderWhitelist || void 0,
        placeholderPattern: placeholderPattern == null ? void 0 : placeholderPattern,
        preserveComments: preserveComments == null ? void 0 : preserveComments,
        syntacticPlaceholders: syntacticPlaceholders == null ? void 0 : syntacticPlaceholders
      };
    }
    function normalizeReplacements(replacements) {
      if (Array.isArray(replacements)) {
        return replacements.reduce((acc, replacement, i) => {
          acc["$" + i] = replacement;
          return acc;
        }, {});
      } else if (typeof replacements === "object" || replacements == null) {
        return replacements || void 0;
      }
      throw new Error("Template replacements must be an array, object, null, or undefined");
    }
  }
});

// node_modules/@babel/template/lib/parse.js
var require_parse = __commonJS({
  "node_modules/@babel/template/lib/parse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = parseAndBuildMetadata;
    var _t = require_lib3();
    var _parser = require_lib9();
    var _codeFrame = require_lib8();
    var {
      isCallExpression: isCallExpression2,
      isExpressionStatement: isExpressionStatement2,
      isFunction,
      isIdentifier: isIdentifier3,
      isJSXIdentifier: isJSXIdentifier3,
      isNewExpression,
      isPlaceholder,
      isStatement,
      isStringLiteral: isStringLiteral2,
      removePropertiesDeep,
      traverse
    } = _t;
    var PATTERN = /^[_$A-Z0-9]+$/;
    function parseAndBuildMetadata(formatter, code2, opts) {
      const {
        placeholderWhitelist,
        placeholderPattern,
        preserveComments,
        syntacticPlaceholders
      } = opts;
      const ast = parseWithCodeFrame(code2, opts.parser, syntacticPlaceholders);
      removePropertiesDeep(ast, {
        preserveComments
      });
      formatter.validate(ast);
      const syntactic = {
        placeholders: [],
        placeholderNames: /* @__PURE__ */ new Set()
      };
      const legacy = {
        placeholders: [],
        placeholderNames: /* @__PURE__ */ new Set()
      };
      const isLegacyRef = {
        value: void 0
      };
      traverse(ast, placeholderVisitorHandler, {
        syntactic,
        legacy,
        isLegacyRef,
        placeholderWhitelist,
        placeholderPattern,
        syntacticPlaceholders
      });
      return Object.assign({
        ast
      }, isLegacyRef.value ? legacy : syntactic);
    }
    function placeholderVisitorHandler(node2, ancestors, state) {
      var _state$placeholderWhi;
      let name2;
      if (isPlaceholder(node2)) {
        if (state.syntacticPlaceholders === false) {
          throw new Error("%%foo%%-style placeholders can't be used when '.syntacticPlaceholders' is false.");
        } else {
          name2 = node2.name.name;
          state.isLegacyRef.value = false;
        }
      } else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) {
        return;
      } else if (isIdentifier3(node2) || isJSXIdentifier3(node2)) {
        name2 = node2.name;
        state.isLegacyRef.value = true;
      } else if (isStringLiteral2(node2)) {
        name2 = node2.value;
        state.isLegacyRef.value = true;
      } else {
        return;
      }
      if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) {
        throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible with '.syntacticPlaceholders: true'");
      }
      if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name2)) && !((_state$placeholderWhi = state.placeholderWhitelist) != null && _state$placeholderWhi.has(name2))) {
        return;
      }
      ancestors = ancestors.slice();
      const {
        node: parent,
        key: key2
      } = ancestors[ancestors.length - 1];
      let type;
      if (isStringLiteral2(node2) || isPlaceholder(node2, {
        expectedNode: "StringLiteral"
      })) {
        type = "string";
      } else if (isNewExpression(parent) && key2 === "arguments" || isCallExpression2(parent) && key2 === "arguments" || isFunction(parent) && key2 === "params") {
        type = "param";
      } else if (isExpressionStatement2(parent) && !isPlaceholder(node2)) {
        type = "statement";
        ancestors = ancestors.slice(0, -1);
      } else if (isStatement(node2) && isPlaceholder(node2)) {
        type = "statement";
      } else {
        type = "other";
      }
      const {
        placeholders,
        placeholderNames
      } = state.isLegacyRef.value ? state.legacy : state.syntactic;
      placeholders.push({
        name: name2,
        type,
        resolve: (ast) => resolveAncestors(ast, ancestors),
        isDuplicate: placeholderNames.has(name2)
      });
      placeholderNames.add(name2);
    }
    function resolveAncestors(ast, ancestors) {
      let parent = ast;
      for (let i = 0; i < ancestors.length - 1; i++) {
        const {
          key: key3,
          index: index3
        } = ancestors[i];
        if (index3 === void 0) {
          parent = parent[key3];
        } else {
          parent = parent[key3][index3];
        }
      }
      const {
        key: key2,
        index: index2
      } = ancestors[ancestors.length - 1];
      return {
        parent,
        key: key2,
        index: index2
      };
    }
    function parseWithCodeFrame(code2, parserOpts, syntacticPlaceholders) {
      const plugins = (parserOpts.plugins || []).slice();
      if (syntacticPlaceholders !== false) {
        plugins.push("placeholders");
      }
      parserOpts = Object.assign({
        allowReturnOutsideFunction: true,
        allowSuperOutsideMethod: true,
        sourceType: "module"
      }, parserOpts, {
        plugins
      });
      try {
        return (0, _parser.parse)(code2, parserOpts);
      } catch (err) {
        const loc = err.loc;
        if (loc) {
          err.message += "\n" + (0, _codeFrame.codeFrameColumns)(code2, {
            start: loc
          });
          err.code = "BABEL_TEMPLATE_PARSE_ERROR";
        }
        throw err;
      }
    }
  }
});

// node_modules/@babel/template/lib/populate.js
var require_populate = __commonJS({
  "node_modules/@babel/template/lib/populate.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = populatePlaceholders;
    var _t = require_lib3();
    var {
      blockStatement,
      cloneNode,
      emptyStatement,
      expressionStatement,
      identifier,
      isStatement,
      isStringLiteral: isStringLiteral2,
      stringLiteral: stringLiteral2,
      validate
    } = _t;
    function populatePlaceholders(metadata, replacements) {
      const ast = cloneNode(metadata.ast);
      if (replacements) {
        metadata.placeholders.forEach((placeholder) => {
          if (!Object.prototype.hasOwnProperty.call(replacements, placeholder.name)) {
            const placeholderName = placeholder.name;
            throw new Error(`Error: No substitution given for "${placeholderName}". If this is not meant to be a
            placeholder you may want to consider passing one of the following options to @babel/template:
            - { placeholderPattern: false, placeholderWhitelist: new Set(['${placeholderName}'])}
            - { placeholderPattern: /^${placeholderName}$/ }`);
          }
        });
        Object.keys(replacements).forEach((key2) => {
          if (!metadata.placeholderNames.has(key2)) {
            throw new Error(`Unknown substitution "${key2}" given`);
          }
        });
      }
      metadata.placeholders.slice().reverse().forEach((placeholder) => {
        try {
          applyReplacement(placeholder, ast, replacements && replacements[placeholder.name] || null);
        } catch (e) {
          e.message = `@babel/template placeholder "${placeholder.name}": ${e.message}`;
          throw e;
        }
      });
      return ast;
    }
    function applyReplacement(placeholder, ast, replacement) {
      if (placeholder.isDuplicate) {
        if (Array.isArray(replacement)) {
          replacement = replacement.map((node2) => cloneNode(node2));
        } else if (typeof replacement === "object") {
          replacement = cloneNode(replacement);
        }
      }
      const {
        parent,
        key: key2,
        index: index2
      } = placeholder.resolve(ast);
      if (placeholder.type === "string") {
        if (typeof replacement === "string") {
          replacement = stringLiteral2(replacement);
        }
        if (!replacement || !isStringLiteral2(replacement)) {
          throw new Error("Expected string substitution");
        }
      } else if (placeholder.type === "statement") {
        if (index2 === void 0) {
          if (!replacement) {
            replacement = emptyStatement();
          } else if (Array.isArray(replacement)) {
            replacement = blockStatement(replacement);
          } else if (typeof replacement === "string") {
            replacement = expressionStatement(identifier(replacement));
          } else if (!isStatement(replacement)) {
            replacement = expressionStatement(replacement);
          }
        } else {
          if (replacement && !Array.isArray(replacement)) {
            if (typeof replacement === "string") {
              replacement = identifier(replacement);
            }
            if (!isStatement(replacement)) {
              replacement = expressionStatement(replacement);
            }
          }
        }
      } else if (placeholder.type === "param") {
        if (typeof replacement === "string") {
          replacement = identifier(replacement);
        }
        if (index2 === void 0)
          throw new Error("Assertion failure.");
      } else {
        if (typeof replacement === "string") {
          replacement = identifier(replacement);
        }
        if (Array.isArray(replacement)) {
          throw new Error("Cannot replace single expression with an array.");
        }
      }
      if (index2 === void 0) {
        validate(parent, key2, replacement);
        parent[key2] = replacement;
      } else {
        const items = parent[key2].slice();
        if (placeholder.type === "statement" || placeholder.type === "param") {
          if (replacement == null) {
            items.splice(index2, 1);
          } else if (Array.isArray(replacement)) {
            items.splice(index2, 1, ...replacement);
          } else {
            items[index2] = replacement;
          }
        } else {
          items[index2] = replacement;
        }
        validate(parent, key2, items);
        parent[key2] = items;
      }
    }
  }
});

// node_modules/@babel/template/lib/string.js
var require_string = __commonJS({
  "node_modules/@babel/template/lib/string.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = stringTemplate;
    var _options = require_options();
    var _parse = require_parse();
    var _populate = require_populate();
    function stringTemplate(formatter, code2, opts) {
      code2 = formatter.code(code2);
      let metadata;
      return (arg) => {
        const replacements = (0, _options.normalizeReplacements)(arg);
        if (!metadata)
          metadata = (0, _parse.default)(formatter, code2, opts);
        return formatter.unwrap((0, _populate.default)(metadata, replacements));
      };
    }
  }
});

// node_modules/@babel/template/lib/literal.js
var require_literal = __commonJS({
  "node_modules/@babel/template/lib/literal.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = literalTemplate;
    var _options = require_options();
    var _parse = require_parse();
    var _populate = require_populate();
    function literalTemplate(formatter, tpl, opts) {
      const {
        metadata,
        names
      } = buildLiteralData(formatter, tpl, opts);
      return (arg) => {
        const defaultReplacements = {};
        arg.forEach((replacement, i) => {
          defaultReplacements[names[i]] = replacement;
        });
        return (arg2) => {
          const replacements = (0, _options.normalizeReplacements)(arg2);
          if (replacements) {
            Object.keys(replacements).forEach((key2) => {
              if (Object.prototype.hasOwnProperty.call(defaultReplacements, key2)) {
                throw new Error("Unexpected replacement overlap.");
              }
            });
          }
          return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements));
        };
      };
    }
    function buildLiteralData(formatter, tpl, opts) {
      let names;
      let nameSet;
      let metadata;
      let prefix = "";
      do {
        prefix += "$";
        const result = buildTemplateCode(tpl, prefix);
        names = result.names;
        nameSet = new Set(names);
        metadata = (0, _parse.default)(formatter, formatter.code(result.code), {
          parser: opts.parser,
          placeholderWhitelist: new Set(result.names.concat(opts.placeholderWhitelist ? Array.from(opts.placeholderWhitelist) : [])),
          placeholderPattern: opts.placeholderPattern,
          preserveComments: opts.preserveComments,
          syntacticPlaceholders: opts.syntacticPlaceholders
        });
      } while (metadata.placeholders.some((placeholder) => placeholder.isDuplicate && nameSet.has(placeholder.name)));
      return {
        metadata,
        names
      };
    }
    function buildTemplateCode(tpl, prefix) {
      const names = [];
      let code2 = tpl[0];
      for (let i = 1; i < tpl.length; i++) {
        const value2 = `${prefix}${i - 1}`;
        names.push(value2);
        code2 += value2 + tpl[i];
      }
      return {
        names,
        code: code2
      };
    }
  }
});

// node_modules/@babel/template/lib/builder.js
var require_builder = __commonJS({
  "node_modules/@babel/template/lib/builder.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = createTemplateBuilder;
    var _options = require_options();
    var _string = require_string();
    var _literal = require_literal();
    var NO_PLACEHOLDER = (0, _options.validate)({
      placeholderPattern: false
    });
    function createTemplateBuilder(formatter, defaultOpts) {
      const templateFnCache = /* @__PURE__ */ new WeakMap();
      const templateAstCache = /* @__PURE__ */ new WeakMap();
      const cachedOpts = defaultOpts || (0, _options.validate)(null);
      return Object.assign((tpl, ...args) => {
        if (typeof tpl === "string") {
          if (args.length > 1)
            throw new Error("Unexpected extra params.");
          return extendedTrace((0, _string.default)(formatter, tpl, (0, _options.merge)(cachedOpts, (0, _options.validate)(args[0]))));
        } else if (Array.isArray(tpl)) {
          let builder = templateFnCache.get(tpl);
          if (!builder) {
            builder = (0, _literal.default)(formatter, tpl, cachedOpts);
            templateFnCache.set(tpl, builder);
          }
          return extendedTrace(builder(args));
        } else if (typeof tpl === "object" && tpl) {
          if (args.length > 0)
            throw new Error("Unexpected extra params.");
          return createTemplateBuilder(formatter, (0, _options.merge)(cachedOpts, (0, _options.validate)(tpl)));
        }
        throw new Error(`Unexpected template param ${typeof tpl}`);
      }, {
        ast: (tpl, ...args) => {
          if (typeof tpl === "string") {
            if (args.length > 1)
              throw new Error("Unexpected extra params.");
            return (0, _string.default)(formatter, tpl, (0, _options.merge)((0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])), NO_PLACEHOLDER))();
          } else if (Array.isArray(tpl)) {
            let builder = templateAstCache.get(tpl);
            if (!builder) {
              builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER));
              templateAstCache.set(tpl, builder);
            }
            return builder(args)();
          }
          throw new Error(`Unexpected template param ${typeof tpl}`);
        }
      });
    }
    function extendedTrace(fn) {
      let rootStack = "";
      try {
        throw new Error();
      } catch (error) {
        if (error.stack) {
          rootStack = error.stack.split("\n").slice(3).join("\n");
        }
      }
      return (arg) => {
        try {
          return fn(arg);
        } catch (err) {
          err.stack += `
    =============
${rootStack}`;
          throw err;
        }
      };
    }
  }
});

// node_modules/@babel/template/lib/index.js
var require_lib11 = __commonJS({
  "node_modules/@babel/template/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.statements = exports.statement = exports.smart = exports.program = exports.expression = exports.default = void 0;
    var formatters = require_formatters();
    var _builder = require_builder();
    var smart = (0, _builder.default)(formatters.smart);
    exports.smart = smart;
    var statement = (0, _builder.default)(formatters.statement);
    exports.statement = statement;
    var statements = (0, _builder.default)(formatters.statements);
    exports.statements = statements;
    var expression = (0, _builder.default)(formatters.expression);
    exports.expression = expression;
    var program = (0, _builder.default)(formatters.program);
    exports.program = program;
    var _default = Object.assign(smart.bind(void 0), {
      smart,
      statement,
      statements,
      expression,
      program,
      ast: smart.ast
    });
    exports.default = _default;
  }
});

// node_modules/@babel/helper-function-name/lib/index.js
var require_lib12 = __commonJS({
  "node_modules/@babel/helper-function-name/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = _default;
    var _template = require_lib11();
    var _t = require_lib3();
    var {
      NOT_LOCAL_BINDING,
      cloneNode,
      identifier,
      isAssignmentExpression,
      isAssignmentPattern,
      isFunction,
      isIdentifier: isIdentifier3,
      isLiteral,
      isNullLiteral,
      isObjectMethod,
      isObjectProperty,
      isRegExpLiteral,
      isRestElement,
      isTemplateLiteral,
      isVariableDeclarator: isVariableDeclarator2,
      toBindingIdentifierName
    } = _t;
    function getFunctionArity(node2) {
      const count = node2.params.findIndex((param) => isAssignmentPattern(param) || isRestElement(param));
      return count === -1 ? node2.params.length : count;
    }
    var buildPropertyMethodAssignmentWrapper = _template.default.statement(`
  (function (FUNCTION_KEY) {
    function FUNCTION_ID() {
      return FUNCTION_KEY.apply(this, arguments);
    }

    FUNCTION_ID.toString = function () {
      return FUNCTION_KEY.toString();
    }

    return FUNCTION_ID;
  })(FUNCTION)
`);
    var buildGeneratorPropertyMethodAssignmentWrapper = _template.default.statement(`
  (function (FUNCTION_KEY) {
    function* FUNCTION_ID() {
      return yield* FUNCTION_KEY.apply(this, arguments);
    }

    FUNCTION_ID.toString = function () {
      return FUNCTION_KEY.toString();
    };

    return FUNCTION_ID;
  })(FUNCTION)
`);
    var visitor = {
      "ReferencedIdentifier|BindingIdentifier"(path, state) {
        if (path.node.name !== state.name)
          return;
        const localDeclar = path.scope.getBindingIdentifier(state.name);
        if (localDeclar !== state.outerDeclar)
          return;
        state.selfReference = true;
        path.stop();
      }
    };
    function getNameFromLiteralId(id) {
      if (isNullLiteral(id)) {
        return "null";
      }
      if (isRegExpLiteral(id)) {
        return `_${id.pattern}_${id.flags}`;
      }
      if (isTemplateLiteral(id)) {
        return id.quasis.map((quasi) => quasi.value.raw).join("");
      }
      if (id.value !== void 0) {
        return id.value + "";
      }
      return "";
    }
    function wrap3(state, method, id, scope) {
      if (state.selfReference) {
        if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
          scope.rename(id.name);
        } else {
          if (!isFunction(method))
            return;
          let build = buildPropertyMethodAssignmentWrapper;
          if (method.generator) {
            build = buildGeneratorPropertyMethodAssignmentWrapper;
          }
          const template = build({
            FUNCTION: method,
            FUNCTION_ID: id,
            FUNCTION_KEY: scope.generateUidIdentifier(id.name)
          }).expression;
          const params = template.callee.body.body[0].params;
          for (let i = 0, len = getFunctionArity(method); i < len; i++) {
            params.push(scope.generateUidIdentifier("x"));
          }
          return template;
        }
      }
      method.id = id;
      scope.getProgramParent().references[id.name] = true;
    }
    function visit3(node2, name2, scope) {
      const state = {
        selfAssignment: false,
        selfReference: false,
        outerDeclar: scope.getBindingIdentifier(name2),
        name: name2
      };
      const binding = scope.getOwnBinding(name2);
      if (binding) {
        if (binding.kind === "param") {
          state.selfReference = true;
        } else {
        }
      } else if (state.outerDeclar || scope.hasGlobal(name2)) {
        scope.traverse(node2, visitor, state);
      }
      return state;
    }
    function _default({
      node: node2,
      parent,
      scope,
      id
    }, localBinding = false, supportUnicodeId = false) {
      if (node2.id)
        return;
      if ((isObjectProperty(parent) || isObjectMethod(parent, {
        kind: "method"
      })) && (!parent.computed || isLiteral(parent.key))) {
        id = parent.key;
      } else if (isVariableDeclarator2(parent)) {
        id = parent.id;
        if (isIdentifier3(id) && !localBinding) {
          const binding = scope.parent.getBinding(id.name);
          if (binding && binding.constant && scope.getBinding(id.name) === binding) {
            node2.id = cloneNode(id);
            node2.id[NOT_LOCAL_BINDING] = true;
            return;
          }
        }
      } else if (isAssignmentExpression(parent, {
        operator: "="
      })) {
        id = parent.left;
      } else if (!id) {
        return;
      }
      let name2;
      if (id && isLiteral(id)) {
        name2 = getNameFromLiteralId(id);
      } else if (id && isIdentifier3(id)) {
        name2 = id.name;
      }
      if (name2 === void 0) {
        return;
      }
      if (!supportUnicodeId && isFunction(node2) && /[\uD800-\uDFFF]/.test(name2)) {
        return;
      }
      name2 = toBindingIdentifierName(name2);
      const newId = identifier(name2);
      newId[NOT_LOCAL_BINDING] = true;
      const state = visit3(node2, name2, scope);
      return wrap3(state, node2, newId, scope) || node2;
    }
  }
});

// node_modules/@babel/traverse/lib/path/conversion.js
var require_conversion = __commonJS({
  "node_modules/@babel/traverse/lib/path/conversion.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.arrowFunctionToExpression = arrowFunctionToExpression;
    exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
    exports.ensureBlock = ensureBlock;
    exports.toComputedKey = toComputedKey;
    exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
    var _t = require_lib3();
    var _helperEnvironmentVisitor = require_lib6();
    var _helperFunctionName = require_lib12();
    var _visitors = require_visitors();
    var {
      arrowFunctionExpression,
      assignmentExpression,
      binaryExpression,
      blockStatement,
      callExpression,
      conditionalExpression,
      expressionStatement,
      identifier,
      isIdentifier: isIdentifier3,
      jsxIdentifier: jsxIdentifier2,
      logicalExpression,
      LOGICAL_OPERATORS,
      memberExpression,
      metaProperty,
      numericLiteral,
      objectExpression,
      restElement,
      returnStatement,
      sequenceExpression,
      spreadElement,
      stringLiteral: stringLiteral2,
      super: _super,
      thisExpression,
      toExpression,
      unaryExpression
    } = _t;
    function toComputedKey() {
      let key2;
      if (this.isMemberExpression()) {
        key2 = this.node.property;
      } else if (this.isProperty() || this.isMethod()) {
        key2 = this.node.key;
      } else {
        throw new ReferenceError("todo");
      }
      if (!this.node.computed) {
        if (isIdentifier3(key2))
          key2 = stringLiteral2(key2.name);
      }
      return key2;
    }
    function ensureBlock() {
      const body = this.get("body");
      const bodyNode = body.node;
      if (Array.isArray(body)) {
        throw new Error("Can't convert array path to a block statement");
      }
      if (!bodyNode) {
        throw new Error("Can't convert node without a body");
      }
      if (body.isBlockStatement()) {
        return bodyNode;
      }
      const statements = [];
      let stringPath = "body";
      let key2;
      let listKey;
      if (body.isStatement()) {
        listKey = "body";
        key2 = 0;
        statements.push(body.node);
      } else {
        stringPath += ".body.0";
        if (this.isFunction()) {
          key2 = "argument";
          statements.push(returnStatement(body.node));
        } else {
          key2 = "expression";
          statements.push(expressionStatement(body.node));
        }
      }
      this.node.body = blockStatement(statements);
      const parentPath = this.get(stringPath);
      body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key2);
      return this.node;
    }
    function arrowFunctionToShadowed() {
      if (!this.isArrowFunctionExpression())
        return;
      this.arrowFunctionToExpression();
    }
    function unwrapFunctionEnvironment() {
      if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
        throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
      }
      hoistFunctionEnvironment(this);
    }
    function setType(path, type) {
      path.node.type = type;
    }
    function arrowFunctionToExpression({
      allowInsertArrow = true,
      allowInsertArrowWithRest = allowInsertArrow,
      specCompliant = false,
      noNewArrows = !specCompliant
    } = {}) {
      if (!this.isArrowFunctionExpression()) {
        throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
      }
      const {
        thisBinding,
        fnPath: fn
      } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow, allowInsertArrowWithRest);
      fn.ensureBlock();
      setType(fn, "FunctionExpression");
      if (!noNewArrows) {
        const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
        if (checkBinding) {
          fn.parentPath.scope.push({
            id: checkBinding,
            init: objectExpression([])
          });
        }
        fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
        fn.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
        return fn.get("callee.object");
      }
      return fn;
    }
    var getSuperCallsVisitor = (0, _visitors.merge)([{
      CallExpression(child, {
        allSuperCalls
      }) {
        if (!child.get("callee").isSuper())
          return;
        allSuperCalls.push(child);
      }
    }, _helperEnvironmentVisitor.default]);
    function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true, allowInsertArrowWithRest = true) {
      let arrowParent;
      let thisEnvFn = fnPath.findParent((p) => {
        if (p.isArrowFunctionExpression()) {
          var _arrowParent;
          (_arrowParent = arrowParent) != null ? _arrowParent : arrowParent = p;
          return false;
        }
        return p.isFunction() || p.isProgram() || p.isClassProperty({
          static: false
        }) || p.isClassPrivateProperty({
          static: false
        });
      });
      const inConstructor = thisEnvFn.isClassMethod({
        kind: "constructor"
      });
      if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
        if (arrowParent) {
          thisEnvFn = arrowParent;
        } else if (allowInsertArrow) {
          fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
          thisEnvFn = fnPath.get("callee");
          fnPath = thisEnvFn.get("body");
        } else {
          throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
        }
      }
      const {
        thisPaths,
        argumentsPaths,
        newTargetPaths,
        superProps,
        superCalls
      } = getScopeInformation(fnPath);
      if (inConstructor && superCalls.length > 0) {
        if (!allowInsertArrow) {
          throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', it's not possible to compile `super()` in an arrow function without compiling classes.\nPlease add '@babel/plugin-transform-classes' to your Babel configuration.");
        }
        if (!allowInsertArrowWithRest) {
          throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-parameters', it's not possible to compile `super()` in an arrow function with default or rest parameters without compiling classes.\nPlease add '@babel/plugin-transform-classes' to your Babel configuration.");
        }
        const allSuperCalls = [];
        thisEnvFn.traverse(getSuperCallsVisitor, {
          allSuperCalls
        });
        const superBinding = getSuperBinding(thisEnvFn);
        allSuperCalls.forEach((superCall) => {
          const callee = identifier(superBinding);
          callee.loc = superCall.node.callee.loc;
          superCall.get("callee").replaceWith(callee);
        });
      }
      if (argumentsPaths.length > 0) {
        const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
          const args = () => identifier("arguments");
          if (thisEnvFn.scope.path.isProgram()) {
            return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral2("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
          } else {
            return args();
          }
        });
        argumentsPaths.forEach((argumentsChild) => {
          const argsRef = identifier(argumentsBinding);
          argsRef.loc = argumentsChild.node.loc;
          argumentsChild.replaceWith(argsRef);
        });
      }
      if (newTargetPaths.length > 0) {
        const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
        newTargetPaths.forEach((targetChild) => {
          const targetRef = identifier(newTargetBinding);
          targetRef.loc = targetChild.node.loc;
          targetChild.replaceWith(targetRef);
        });
      }
      if (superProps.length > 0) {
        if (!allowInsertArrow) {
          throw superProps[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', it's not possible to compile `super.prop` in an arrow function without compiling classes.\nPlease add '@babel/plugin-transform-classes' to your Babel configuration.");
        }
        const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
        flatSuperProps.forEach((superProp) => {
          const key2 = superProp.node.computed ? "" : superProp.get("property").node.name;
          const superParentPath = superProp.parentPath;
          const isAssignment = superParentPath.isAssignmentExpression({
            left: superProp.node
          });
          const isCall = superParentPath.isCallExpression({
            callee: superProp.node
          });
          const isTaggedTemplate = superParentPath.isTaggedTemplateExpression({
            tag: superProp.node
          });
          const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key2);
          const args = [];
          if (superProp.node.computed) {
            args.push(superProp.get("property").node);
          }
          if (isAssignment) {
            const value2 = superParentPath.node.right;
            args.push(value2);
          }
          const call = callExpression(identifier(superBinding), args);
          if (isCall) {
            superParentPath.unshiftContainer("arguments", thisExpression());
            superProp.replaceWith(memberExpression(call, identifier("call")));
            thisPaths.push(superParentPath.get("arguments.0"));
          } else if (isAssignment) {
            superParentPath.replaceWith(call);
          } else if (isTaggedTemplate) {
            superProp.replaceWith(callExpression(memberExpression(call, identifier("bind"), false), [thisExpression()]));
            thisPaths.push(superProp.get("arguments.0"));
          } else {
            superProp.replaceWith(call);
          }
        });
      }
      let thisBinding;
      if (thisPaths.length > 0 || !noNewArrows) {
        thisBinding = getThisBinding(thisEnvFn, inConstructor);
        if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
          thisPaths.forEach((thisChild) => {
            const thisRef = thisChild.isJSX() ? jsxIdentifier2(thisBinding) : identifier(thisBinding);
            thisRef.loc = thisChild.node.loc;
            thisChild.replaceWith(thisRef);
          });
          if (!noNewArrows)
            thisBinding = null;
        }
      }
      return {
        thisBinding,
        fnPath
      };
    }
    function isLogicalOp(op) {
      return LOGICAL_OPERATORS.includes(op);
    }
    function standardizeSuperProperty(superProp) {
      if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
        const assignmentPath = superProp.parentPath;
        const op = assignmentPath.node.operator.slice(0, -1);
        const value2 = assignmentPath.node.right;
        const isLogicalAssignment = isLogicalOp(op);
        if (superProp.node.computed) {
          const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
          const object = superProp.node.object;
          const property = superProp.node.property;
          assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
          assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value2));
        } else {
          const object = superProp.node.object;
          const property = superProp.node.property;
          assignmentPath.get("left").replaceWith(memberExpression(object, property));
          assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value2));
        }
        if (isLogicalAssignment) {
          assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right));
        } else {
          assignmentPath.node.operator = "=";
        }
        return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
      } else if (superProp.parentPath.isUpdateExpression()) {
        const updateExpr = superProp.parentPath;
        const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
        const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
        const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral(1)))];
        if (!superProp.parentPath.node.prefix) {
          parts.push(identifier(tmp.name));
        }
        updateExpr.replaceWith(sequenceExpression(parts));
        const left = updateExpr.get("expressions.0.right");
        const right = updateExpr.get("expressions.1.left");
        return [left, right];
      }
      return [superProp];
      function rightExpression(op, left, right) {
        if (op === "=") {
          return assignmentExpression("=", left, right);
        } else {
          return binaryExpression(op, left, right);
        }
      }
    }
    function hasSuperClass(thisEnvFn) {
      return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
    }
    var assignSuperThisVisitor = (0, _visitors.merge)([{
      CallExpression(child, {
        supers,
        thisBinding
      }) {
        if (!child.get("callee").isSuper())
          return;
        if (supers.has(child.node))
          return;
        supers.add(child.node);
        child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
      }
    }, _helperEnvironmentVisitor.default]);
    function getThisBinding(thisEnvFn, inConstructor) {
      return getBinding(thisEnvFn, "this", (thisBinding) => {
        if (!inConstructor || !hasSuperClass(thisEnvFn))
          return thisExpression();
        thisEnvFn.traverse(assignSuperThisVisitor, {
          supers: /* @__PURE__ */ new WeakSet(),
          thisBinding
        });
      });
    }
    function getSuperBinding(thisEnvFn) {
      return getBinding(thisEnvFn, "supercall", () => {
        const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
        return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
      });
    }
    function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
      const op = isAssignment ? "set" : "get";
      return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
        const argsList = [];
        let fnBody;
        if (propName) {
          fnBody = memberExpression(_super(), identifier(propName));
        } else {
          const method = thisEnvFn.scope.generateUidIdentifier("prop");
          argsList.unshift(method);
          fnBody = memberExpression(_super(), identifier(method.name), true);
        }
        if (isAssignment) {
          const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
          argsList.push(valueIdent);
          fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
        }
        return arrowFunctionExpression(argsList, fnBody);
      });
    }
    function getBinding(thisEnvFn, key2, init) {
      const cacheKey = "binding:" + key2;
      let data3 = thisEnvFn.getData(cacheKey);
      if (!data3) {
        const id = thisEnvFn.scope.generateUidIdentifier(key2);
        data3 = id.name;
        thisEnvFn.setData(cacheKey, data3);
        thisEnvFn.scope.push({
          id,
          init: init(data3)
        });
      }
      return data3;
    }
    var getScopeInformationVisitor = (0, _visitors.merge)([{
      ThisExpression(child, {
        thisPaths
      }) {
        thisPaths.push(child);
      },
      JSXIdentifier(child, {
        thisPaths
      }) {
        if (child.node.name !== "this")
          return;
        if (!child.parentPath.isJSXMemberExpression({
          object: child.node
        }) && !child.parentPath.isJSXOpeningElement({
          name: child.node
        })) {
          return;
        }
        thisPaths.push(child);
      },
      CallExpression(child, {
        superCalls
      }) {
        if (child.get("callee").isSuper())
          superCalls.push(child);
      },
      MemberExpression(child, {
        superProps
      }) {
        if (child.get("object").isSuper())
          superProps.push(child);
      },
      Identifier(child, {
        argumentsPaths
      }) {
        if (!child.isReferencedIdentifier({
          name: "arguments"
        }))
          return;
        let curr = child.scope;
        do {
          if (curr.hasOwnBinding("arguments")) {
            curr.rename("arguments");
            return;
          }
          if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
            break;
          }
        } while (curr = curr.parent);
        argumentsPaths.push(child);
      },
      MetaProperty(child, {
        newTargetPaths
      }) {
        if (!child.get("meta").isIdentifier({
          name: "new"
        }))
          return;
        if (!child.get("property").isIdentifier({
          name: "target"
        }))
          return;
        newTargetPaths.push(child);
      }
    }, _helperEnvironmentVisitor.default]);
    function getScopeInformation(fnPath) {
      const thisPaths = [];
      const argumentsPaths = [];
      const newTargetPaths = [];
      const superProps = [];
      const superCalls = [];
      fnPath.traverse(getScopeInformationVisitor, {
        thisPaths,
        argumentsPaths,
        newTargetPaths,
        superProps,
        superCalls
      });
      return {
        thisPaths,
        argumentsPaths,
        newTargetPaths,
        superProps,
        superCalls
      };
    }
  }
});

// node_modules/@babel/traverse/lib/path/introspection.js
var require_introspection = __commonJS({
  "node_modules/@babel/traverse/lib/path/introspection.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
    exports._resolve = _resolve;
    exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
    exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
    exports.equals = equals;
    exports.getSource = getSource;
    exports.has = has2;
    exports.is = void 0;
    exports.isCompletionRecord = isCompletionRecord;
    exports.isConstantExpression = isConstantExpression;
    exports.isInStrictMode = isInStrictMode;
    exports.isNodeType = isNodeType;
    exports.isStatementOrBlock = isStatementOrBlock;
    exports.isStatic = isStatic;
    exports.isnt = isnt;
    exports.matchesPattern = matchesPattern;
    exports.referencesImport = referencesImport;
    exports.resolve = resolve;
    exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
    var _t = require_lib3();
    var {
      STATEMENT_OR_BLOCK_KEYS,
      VISITOR_KEYS,
      isBlockStatement,
      isExpression,
      isIdentifier: isIdentifier3,
      isLiteral,
      isStringLiteral: isStringLiteral2,
      isType,
      matchesPattern: _matchesPattern
    } = _t;
    function matchesPattern(pattern, allowPartial) {
      return _matchesPattern(this.node, pattern, allowPartial);
    }
    function has2(key2) {
      const val = this.node && this.node[key2];
      if (val && Array.isArray(val)) {
        return !!val.length;
      } else {
        return !!val;
      }
    }
    function isStatic() {
      return this.scope.isStatic(this.node);
    }
    var is2 = has2;
    exports.is = is2;
    function isnt(key2) {
      return !this.has(key2);
    }
    function equals(key2, value2) {
      return this.node[key2] === value2;
    }
    function isNodeType(type) {
      return isType(this.type, type);
    }
    function canHaveVariableDeclarationOrExpression() {
      return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
    }
    function canSwapBetweenExpressionAndStatement(replacement) {
      if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
        return false;
      }
      if (this.isExpression()) {
        return isBlockStatement(replacement);
      } else if (this.isBlockStatement()) {
        return isExpression(replacement);
      }
      return false;
    }
    function isCompletionRecord(allowInsideFunction) {
      let path = this;
      let first = true;
      do {
        const {
          type,
          container
        } = path;
        if (!first && (path.isFunction() || type === "StaticBlock")) {
          return !!allowInsideFunction;
        }
        first = false;
        if (Array.isArray(container) && path.key !== container.length - 1) {
          return false;
        }
      } while ((path = path.parentPath) && !path.isProgram() && !path.isDoExpression());
      return true;
    }
    function isStatementOrBlock() {
      if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
        return false;
      } else {
        return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
      }
    }
    function referencesImport(moduleSource, importName) {
      if (!this.isReferencedIdentifier()) {
        if (this.isJSXMemberExpression() && this.node.property.name === importName || (this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral2(this.node.property, {
          value: importName
        }) : this.node.property.name === importName)) {
          const object = this.get("object");
          return object.isReferencedIdentifier() && object.referencesImport(moduleSource, "*");
        }
        return false;
      }
      const binding = this.scope.getBinding(this.node.name);
      if (!binding || binding.kind !== "module")
        return false;
      const path = binding.path;
      const parent = path.parentPath;
      if (!parent.isImportDeclaration())
        return false;
      if (parent.node.source.value === moduleSource) {
        if (!importName)
          return true;
      } else {
        return false;
      }
      if (path.isImportDefaultSpecifier() && importName === "default") {
        return true;
      }
      if (path.isImportNamespaceSpecifier() && importName === "*") {
        return true;
      }
      if (path.isImportSpecifier() && isIdentifier3(path.node.imported, {
        name: importName
      })) {
        return true;
      }
      return false;
    }
    function getSource() {
      const node2 = this.node;
      if (node2.end) {
        const code2 = this.hub.getCode();
        if (code2)
          return code2.slice(node2.start, node2.end);
      }
      return "";
    }
    function willIMaybeExecuteBefore(target) {
      return this._guessExecutionStatusRelativeTo(target) !== "after";
    }
    function getOuterFunction(path) {
      return path.isProgram() ? path : (path.parentPath.scope.getFunctionParent() || path.parentPath.scope.getProgramParent()).path;
    }
    function isExecutionUncertain(type, key2) {
      switch (type) {
        case "LogicalExpression":
          return key2 === "right";
        case "ConditionalExpression":
        case "IfStatement":
          return key2 === "consequent" || key2 === "alternate";
        case "WhileStatement":
        case "DoWhileStatement":
        case "ForInStatement":
        case "ForOfStatement":
          return key2 === "body";
        case "ForStatement":
          return key2 === "body" || key2 === "update";
        case "SwitchStatement":
          return key2 === "cases";
        case "TryStatement":
          return key2 === "handler";
        case "AssignmentPattern":
          return key2 === "right";
        case "OptionalMemberExpression":
          return key2 === "property";
        case "OptionalCallExpression":
          return key2 === "arguments";
        default:
          return false;
      }
    }
    function isExecutionUncertainInList(paths, maxIndex) {
      for (let i = 0; i < maxIndex; i++) {
        const path = paths[i];
        if (isExecutionUncertain(path.parent.type, path.parentKey)) {
          return true;
        }
      }
      return false;
    }
    var SYMBOL_CHECKING = Symbol();
    function _guessExecutionStatusRelativeTo(target) {
      return _guessExecutionStatusRelativeToCached(this, target, /* @__PURE__ */ new Map());
    }
    function _guessExecutionStatusRelativeToCached(base2, target, cache) {
      const funcParent = {
        this: getOuterFunction(base2),
        target: getOuterFunction(target)
      };
      if (funcParent.target.node !== funcParent.this.node) {
        return _guessExecutionStatusRelativeToDifferentFunctionsCached(base2, funcParent.target, cache);
      }
      const paths = {
        target: target.getAncestry(),
        this: base2.getAncestry()
      };
      if (paths.target.indexOf(base2) >= 0)
        return "after";
      if (paths.this.indexOf(target) >= 0)
        return "before";
      let commonPath;
      const commonIndex = {
        target: 0,
        this: 0
      };
      while (!commonPath && commonIndex.this < paths.this.length) {
        const path = paths.this[commonIndex.this];
        commonIndex.target = paths.target.indexOf(path);
        if (commonIndex.target >= 0) {
          commonPath = path;
        } else {
          commonIndex.this++;
        }
      }
      if (!commonPath) {
        throw new Error("Internal Babel error - The two compared nodes don't appear to belong to the same program.");
      }
      if (isExecutionUncertainInList(paths.this, commonIndex.this - 1) || isExecutionUncertainInList(paths.target, commonIndex.target - 1)) {
        return "unknown";
      }
      const divergence = {
        this: paths.this[commonIndex.this - 1],
        target: paths.target[commonIndex.target - 1]
      };
      if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) {
        return divergence.target.key > divergence.this.key ? "before" : "after";
      }
      const keys2 = VISITOR_KEYS[commonPath.type];
      const keyPosition = {
        this: keys2.indexOf(divergence.this.parentKey),
        target: keys2.indexOf(divergence.target.parentKey)
      };
      return keyPosition.target > keyPosition.this ? "before" : "after";
    }
    function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base2, target, cache) {
      if (!target.isFunctionDeclaration()) {
        if (_guessExecutionStatusRelativeToCached(base2, target, cache) === "before") {
          return "before";
        }
        return "unknown";
      } else if (target.parentPath.isExportDeclaration()) {
        return "unknown";
      }
      const binding = target.scope.getBinding(target.node.id.name);
      if (!binding.references)
        return "before";
      const referencePaths = binding.referencePaths;
      let allStatus;
      for (const path of referencePaths) {
        const childOfFunction = !!path.find((path2) => path2.node === target.node);
        if (childOfFunction)
          continue;
        if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
          return "unknown";
        }
        const status = _guessExecutionStatusRelativeToCached(base2, path, cache);
        if (allStatus && allStatus !== status) {
          return "unknown";
        } else {
          allStatus = status;
        }
      }
      return allStatus;
    }
    function _guessExecutionStatusRelativeToDifferentFunctionsCached(base2, target, cache) {
      let nodeMap = cache.get(base2.node);
      let cached;
      if (!nodeMap) {
        cache.set(base2.node, nodeMap = /* @__PURE__ */ new Map());
      } else if (cached = nodeMap.get(target.node)) {
        if (cached === SYMBOL_CHECKING) {
          return "unknown";
        }
        return cached;
      }
      nodeMap.set(target.node, SYMBOL_CHECKING);
      const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base2, target, cache);
      nodeMap.set(target.node, result);
      return result;
    }
    function resolve(dangerous, resolved) {
      return this._resolve(dangerous, resolved) || this;
    }
    function _resolve(dangerous, resolved) {
      if (resolved && resolved.indexOf(this) >= 0)
        return;
      resolved = resolved || [];
      resolved.push(this);
      if (this.isVariableDeclarator()) {
        if (this.get("id").isIdentifier()) {
          return this.get("init").resolve(dangerous, resolved);
        } else {
        }
      } else if (this.isReferencedIdentifier()) {
        const binding = this.scope.getBinding(this.node.name);
        if (!binding)
          return;
        if (!binding.constant)
          return;
        if (binding.kind === "module")
          return;
        if (binding.path !== this) {
          const ret = binding.path.resolve(dangerous, resolved);
          if (this.find((parent) => parent.node === ret.node))
            return;
          return ret;
        }
      } else if (this.isTypeCastExpression()) {
        return this.get("expression").resolve(dangerous, resolved);
      } else if (dangerous && this.isMemberExpression()) {
        const targetKey = this.toComputedKey();
        if (!isLiteral(targetKey))
          return;
        const targetName = targetKey.value;
        const target = this.get("object").resolve(dangerous, resolved);
        if (target.isObjectExpression()) {
          const props = target.get("properties");
          for (const prop of props) {
            if (!prop.isProperty())
              continue;
            const key2 = prop.get("key");
            let match = prop.isnt("computed") && key2.isIdentifier({
              name: targetName
            });
            match = match || key2.isLiteral({
              value: targetName
            });
            if (match)
              return prop.get("value").resolve(dangerous, resolved);
          }
        } else if (target.isArrayExpression() && !isNaN(+targetName)) {
          const elems = target.get("elements");
          const elem = elems[targetName];
          if (elem)
            return elem.resolve(dangerous, resolved);
        }
      }
    }
    function isConstantExpression() {
      if (this.isIdentifier()) {
        const binding = this.scope.getBinding(this.node.name);
        if (!binding)
          return false;
        return binding.constant;
      }
      if (this.isLiteral()) {
        if (this.isRegExpLiteral()) {
          return false;
        }
        if (this.isTemplateLiteral()) {
          return this.get("expressions").every((expression) => expression.isConstantExpression());
        }
        return true;
      }
      if (this.isUnaryExpression()) {
        if (this.node.operator !== "void") {
          return false;
        }
        return this.get("argument").isConstantExpression();
      }
      if (this.isBinaryExpression()) {
        const {
          operator
        } = this.node;
        return operator !== "in" && operator !== "instanceof" && this.get("left").isConstantExpression() && this.get("right").isConstantExpression();
      }
      return false;
    }
    function isInStrictMode() {
      const start3 = this.isProgram() ? this : this.parentPath;
      const strictParent = start3.find((path) => {
        if (path.isProgram({
          sourceType: "module"
        }))
          return true;
        if (path.isClass())
          return true;
        if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
          return false;
        }
        let body;
        if (path.isFunction()) {
          body = path.node.body;
        } else if (path.isProgram()) {
          body = path.node;
        } else {
          return false;
        }
        for (const directive of body.directives) {
          if (directive.value.value === "use strict") {
            return true;
          }
        }
      });
      return !!strictParent;
    }
  }
});

// node_modules/@babel/traverse/lib/path/context.js
var require_context = __commonJS({
  "node_modules/@babel/traverse/lib/path/context.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._call = _call;
    exports._getQueueContexts = _getQueueContexts;
    exports._resyncKey = _resyncKey;
    exports._resyncList = _resyncList;
    exports._resyncParent = _resyncParent;
    exports._resyncRemoved = _resyncRemoved;
    exports.call = call;
    exports.isBlacklisted = exports.isDenylisted = isDenylisted;
    exports.popContext = popContext;
    exports.pushContext = pushContext;
    exports.requeue = requeue;
    exports.resync = resync;
    exports.setContext = setContext;
    exports.setKey = setKey;
    exports.setScope = setScope;
    exports.setup = setup;
    exports.skip = skip;
    exports.skipKey = skipKey;
    exports.stop = stop;
    exports.visit = visit3;
    var _traverseNode = require_traverse_node();
    var _index = require_path();
    function call(key2) {
      const opts = this.opts;
      this.debug(key2);
      if (this.node) {
        if (this._call(opts[key2]))
          return true;
      }
      if (this.node) {
        return this._call(opts[this.node.type] && opts[this.node.type][key2]);
      }
      return false;
    }
    function _call(fns) {
      if (!fns)
        return false;
      for (const fn of fns) {
        if (!fn)
          continue;
        const node2 = this.node;
        if (!node2)
          return true;
        const ret = fn.call(this.state, this, this.state);
        if (ret && typeof ret === "object" && typeof ret.then === "function") {
          throw new Error(`You appear to be using a plugin with an async traversal visitor, which your current version of Babel does not support. If you're using a published plugin, you may need to upgrade your @babel/core version.`);
        }
        if (ret) {
          throw new Error(`Unexpected return value from visitor method ${fn}`);
        }
        if (this.node !== node2)
          return true;
        if (this._traverseFlags > 0)
          return true;
      }
      return false;
    }
    function isDenylisted() {
      var _this$opts$denylist;
      const denylist = (_this$opts$denylist = this.opts.denylist) != null ? _this$opts$denylist : this.opts.blacklist;
      return denylist && denylist.indexOf(this.node.type) > -1;
    }
    function restoreContext(path, context) {
      if (path.context !== context) {
        path.context = context;
        path.state = context.state;
        path.opts = context.opts;
      }
    }
    function visit3() {
      if (!this.node) {
        return false;
      }
      if (this.isDenylisted()) {
        return false;
      }
      if (this.opts.shouldSkip && this.opts.shouldSkip(this)) {
        return false;
      }
      const currentContext = this.context;
      if (this.shouldSkip || this.call("enter")) {
        this.debug("Skip...");
        return this.shouldStop;
      }
      restoreContext(this, currentContext);
      this.debug("Recursing into...");
      this.shouldStop = (0, _traverseNode.traverseNode)(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
      restoreContext(this, currentContext);
      this.call("exit");
      return this.shouldStop;
    }
    function skip() {
      this.shouldSkip = true;
    }
    function skipKey(key2) {
      if (this.skipKeys == null) {
        this.skipKeys = {};
      }
      this.skipKeys[key2] = true;
    }
    function stop() {
      this._traverseFlags |= _index.SHOULD_SKIP | _index.SHOULD_STOP;
    }
    function setScope() {
      if (this.opts && this.opts.noScope)
        return;
      let path = this.parentPath;
      if ((this.key === "key" || this.listKey === "decorators") && path.isMethod() || this.key === "discriminant" && path.isSwitchStatement()) {
        path = path.parentPath;
      }
      let target;
      while (path && !target) {
        if (path.opts && path.opts.noScope)
          return;
        target = path.scope;
        path = path.parentPath;
      }
      this.scope = this.getScope(target);
      if (this.scope)
        this.scope.init();
    }
    function setContext(context) {
      if (this.skipKeys != null) {
        this.skipKeys = {};
      }
      this._traverseFlags = 0;
      if (context) {
        this.context = context;
        this.state = context.state;
        this.opts = context.opts;
      }
      this.setScope();
      return this;
    }
    function resync() {
      if (this.removed)
        return;
      this._resyncParent();
      this._resyncList();
      this._resyncKey();
    }
    function _resyncParent() {
      if (this.parentPath) {
        this.parent = this.parentPath.node;
      }
    }
    function _resyncKey() {
      if (!this.container)
        return;
      if (this.node === this.container[this.key]) {
        return;
      }
      if (Array.isArray(this.container)) {
        for (let i = 0; i < this.container.length; i++) {
          if (this.container[i] === this.node) {
            this.setKey(i);
            return;
          }
        }
      } else {
        for (const key2 of Object.keys(this.container)) {
          if (this.container[key2] === this.node) {
            this.setKey(key2);
            return;
          }
        }
      }
      this.key = null;
    }
    function _resyncList() {
      if (!this.parent || !this.inList)
        return;
      const newContainer = this.parent[this.listKey];
      if (this.container === newContainer)
        return;
      this.container = newContainer || null;
    }
    function _resyncRemoved() {
      if (this.key == null || !this.container || this.container[this.key] !== this.node) {
        this._markRemoved();
      }
    }
    function popContext() {
      this.contexts.pop();
      if (this.contexts.length > 0) {
        this.setContext(this.contexts[this.contexts.length - 1]);
      } else {
        this.setContext(void 0);
      }
    }
    function pushContext(context) {
      this.contexts.push(context);
      this.setContext(context);
    }
    function setup(parentPath, container, listKey, key2) {
      this.listKey = listKey;
      this.container = container;
      this.parentPath = parentPath || this.parentPath;
      this.setKey(key2);
    }
    function setKey(key2) {
      var _this$node;
      this.key = key2;
      this.node = this.container[this.key];
      this.type = (_this$node = this.node) == null ? void 0 : _this$node.type;
    }
    function requeue(pathToQueue = this) {
      if (pathToQueue.removed)
        return;
      ;
      const contexts = this.contexts;
      for (const context of contexts) {
        context.maybeQueue(pathToQueue);
      }
    }
    function _getQueueContexts() {
      let path = this;
      let contexts = this.contexts;
      while (!contexts.length) {
        path = path.parentPath;
        if (!path)
          break;
        contexts = path.contexts;
      }
      return contexts;
    }
  }
});

// node_modules/@babel/traverse/lib/path/lib/removal-hooks.js
var require_removal_hooks = __commonJS({
  "node_modules/@babel/traverse/lib/path/lib/removal-hooks.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.hooks = void 0;
    var hooks = [function(self2, parent) {
      const removeParent = self2.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self2.key === "declaration" && parent.isExportDeclaration() || self2.key === "body" && parent.isLabeledStatement() || self2.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self2.key === "expression" && parent.isExpressionStatement();
      if (removeParent) {
        parent.remove();
        return true;
      }
    }, function(self2, parent) {
      if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
        parent.replaceWith(parent.node.expressions[0]);
        return true;
      }
    }, function(self2, parent) {
      if (parent.isBinary()) {
        if (self2.key === "left") {
          parent.replaceWith(parent.node.right);
        } else {
          parent.replaceWith(parent.node.left);
        }
        return true;
      }
    }, function(self2, parent) {
      if (parent.isIfStatement() && self2.key === "consequent" || self2.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
        self2.replaceWith({
          type: "BlockStatement",
          body: []
        });
        return true;
      }
    }];
    exports.hooks = hooks;
  }
});

// node_modules/@babel/traverse/lib/path/removal.js
var require_removal = __commonJS({
  "node_modules/@babel/traverse/lib/path/removal.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._assertUnremoved = _assertUnremoved;
    exports._callRemovalHooks = _callRemovalHooks;
    exports._markRemoved = _markRemoved;
    exports._remove = _remove;
    exports._removeFromScope = _removeFromScope;
    exports.remove = remove;
    var _removalHooks = require_removal_hooks();
    var _cache = require_cache();
    var _index = require_path();
    function remove() {
      var _this$opts;
      this._assertUnremoved();
      this.resync();
      if (!((_this$opts = this.opts) != null && _this$opts.noScope)) {
        this._removeFromScope();
      }
      if (this._callRemovalHooks()) {
        this._markRemoved();
        return;
      }
      this.shareCommentsWithSiblings();
      this._remove();
      this._markRemoved();
    }
    function _removeFromScope() {
      const bindings = this.getBindingIdentifiers();
      Object.keys(bindings).forEach((name2) => this.scope.removeBinding(name2));
    }
    function _callRemovalHooks() {
      for (const fn of _removalHooks.hooks) {
        if (fn(this, this.parentPath))
          return true;
      }
    }
    function _remove() {
      if (Array.isArray(this.container)) {
        this.container.splice(this.key, 1);
        this.updateSiblingKeys(this.key, -1);
      } else {
        this._replaceWith(null);
      }
    }
    function _markRemoved() {
      this._traverseFlags |= _index.SHOULD_SKIP | _index.REMOVED;
      if (this.parent)
        _cache.path.get(this.parent).delete(this.node);
      this.node = null;
    }
    function _assertUnremoved() {
      if (this.removed) {
        throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
      }
    }
  }
});

// node_modules/@babel/traverse/lib/path/lib/hoister.js
var require_hoister = __commonJS({
  "node_modules/@babel/traverse/lib/path/lib/hoister.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _t = require_lib3();
    var _t2 = _t;
    var {
      react
    } = _t;
    var {
      cloneNode,
      jsxExpressionContainer,
      variableDeclaration,
      variableDeclarator
    } = _t2;
    var referenceVisitor = {
      ReferencedIdentifier(path, state) {
        if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
          return;
        }
        if (path.node.name === "this") {
          let scope = path.scope;
          do {
            if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
              break;
            }
          } while (scope = scope.parent);
          if (scope)
            state.breakOnScopePaths.push(scope.path);
        }
        const binding = path.scope.getBinding(path.node.name);
        if (!binding)
          return;
        for (const violation of binding.constantViolations) {
          if (violation.scope !== binding.path.scope) {
            state.mutableBinding = true;
            path.stop();
            return;
          }
        }
        if (binding !== state.scope.getBinding(path.node.name))
          return;
        state.bindings[path.node.name] = binding;
      }
    };
    var PathHoister = class {
      constructor(path, scope) {
        this.breakOnScopePaths = void 0;
        this.bindings = void 0;
        this.mutableBinding = void 0;
        this.scopes = void 0;
        this.scope = void 0;
        this.path = void 0;
        this.attachAfter = void 0;
        this.breakOnScopePaths = [];
        this.bindings = {};
        this.mutableBinding = false;
        this.scopes = [];
        this.scope = scope;
        this.path = path;
        this.attachAfter = false;
      }
      isCompatibleScope(scope) {
        for (const key2 of Object.keys(this.bindings)) {
          const binding = this.bindings[key2];
          if (!scope.bindingIdentifierEquals(key2, binding.identifier)) {
            return false;
          }
        }
        return true;
      }
      getCompatibleScopes() {
        let scope = this.path.scope;
        do {
          if (this.isCompatibleScope(scope)) {
            this.scopes.push(scope);
          } else {
            break;
          }
          if (this.breakOnScopePaths.indexOf(scope.path) >= 0) {
            break;
          }
        } while (scope = scope.parent);
      }
      getAttachmentPath() {
        let path = this._getAttachmentPath();
        if (!path)
          return;
        let targetScope = path.scope;
        if (targetScope.path === path) {
          targetScope = path.scope.parent;
        }
        if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
          for (const name2 of Object.keys(this.bindings)) {
            if (!targetScope.hasOwnBinding(name2))
              continue;
            const binding = this.bindings[name2];
            if (binding.kind === "param" || binding.path.parentKey === "params") {
              continue;
            }
            const bindingParentPath = this.getAttachmentParentForPath(binding.path);
            if (bindingParentPath.key >= path.key) {
              this.attachAfter = true;
              path = binding.path;
              for (const violationPath of binding.constantViolations) {
                if (this.getAttachmentParentForPath(violationPath).key > path.key) {
                  path = violationPath;
                }
              }
            }
          }
        }
        return path;
      }
      _getAttachmentPath() {
        const scopes = this.scopes;
        const scope = scopes.pop();
        if (!scope)
          return;
        if (scope.path.isFunction()) {
          if (this.hasOwnParamBindings(scope)) {
            if (this.scope === scope)
              return;
            const bodies = scope.path.get("body").get("body");
            for (let i = 0; i < bodies.length; i++) {
              if (bodies[i].node._blockHoist)
                continue;
              return bodies[i];
            }
          } else {
            return this.getNextScopeAttachmentParent();
          }
        } else if (scope.path.isProgram()) {
          return this.getNextScopeAttachmentParent();
        }
      }
      getNextScopeAttachmentParent() {
        const scope = this.scopes.pop();
        if (scope)
          return this.getAttachmentParentForPath(scope.path);
      }
      getAttachmentParentForPath(path) {
        do {
          if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
            return path;
          }
        } while (path = path.parentPath);
      }
      hasOwnParamBindings(scope) {
        for (const name2 of Object.keys(this.bindings)) {
          if (!scope.hasOwnBinding(name2))
            continue;
          const binding = this.bindings[name2];
          if (binding.kind === "param" && binding.constant)
            return true;
        }
        return false;
      }
      run() {
        this.path.traverse(referenceVisitor, this);
        if (this.mutableBinding)
          return;
        this.getCompatibleScopes();
        const attachTo = this.getAttachmentPath();
        if (!attachTo)
          return;
        if (attachTo.getFunctionParent() === this.path.getFunctionParent())
          return;
        let uid = attachTo.scope.generateUidIdentifier("ref");
        const declarator = variableDeclarator(uid, this.path.node);
        const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
        const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]);
        const parent = this.path.parentPath;
        if (parent.isJSXElement() && this.path.container === parent.node.children) {
          uid = jsxExpressionContainer(uid);
        }
        this.path.replaceWith(cloneNode(uid));
        return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
      }
    };
    exports.default = PathHoister;
  }
});

// node_modules/@babel/traverse/lib/path/modification.js
var require_modification = __commonJS({
  "node_modules/@babel/traverse/lib/path/modification.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._containerInsert = _containerInsert;
    exports._containerInsertAfter = _containerInsertAfter;
    exports._containerInsertBefore = _containerInsertBefore;
    exports._verifyNodeList = _verifyNodeList;
    exports.hoist = hoist;
    exports.insertAfter = insertAfter;
    exports.insertBefore = insertBefore;
    exports.pushContainer = pushContainer;
    exports.unshiftContainer = unshiftContainer;
    exports.updateSiblingKeys = updateSiblingKeys;
    var _cache = require_cache();
    var _hoister = require_hoister();
    var _index = require_path();
    var _t = require_lib3();
    var {
      arrowFunctionExpression,
      assertExpression,
      assignmentExpression,
      blockStatement,
      callExpression,
      cloneNode,
      expressionStatement,
      isAssignmentExpression,
      isCallExpression: isCallExpression2,
      isExportNamedDeclaration: isExportNamedDeclaration2,
      isExpression,
      isIdentifier: isIdentifier3,
      isSequenceExpression,
      isSuper,
      thisExpression
    } = _t;
    function insertBefore(nodes_) {
      this._assertUnremoved();
      const nodes = this._verifyNodeList(nodes_);
      const {
        parentPath,
        parent
      } = this;
      if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration2(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
        return parentPath.insertBefore(nodes);
      } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
        if (this.node)
          nodes.push(this.node);
        return this.replaceExpressionWithStatements(nodes);
      } else if (Array.isArray(this.container)) {
        return this._containerInsertBefore(nodes);
      } else if (this.isStatementOrBlock()) {
        const node2 = this.node;
        const shouldInsertCurrentNode = node2 && (!this.isExpressionStatement() || node2.expression != null);
        this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node2] : []));
        return this.unshiftContainer("body", nodes);
      } else {
        throw new Error("We don't know what to do with this node type. We were previously a Statement but we can't fit in here?");
      }
    }
    function _containerInsert(from, nodes) {
      this.updateSiblingKeys(from, nodes.length);
      const paths = [];
      this.container.splice(from, 0, ...nodes);
      for (let i = 0; i < nodes.length; i++) {
        const to = from + i;
        const path = this.getSibling(to);
        paths.push(path);
        if (this.context && this.context.queue) {
          path.pushContext(this.context);
        }
      }
      const contexts = this._getQueueContexts();
      for (const path of paths) {
        path.setScope();
        path.debug("Inserted.");
        for (const context of contexts) {
          context.maybeQueue(path, true);
        }
      }
      return paths;
    }
    function _containerInsertBefore(nodes) {
      return this._containerInsert(this.key, nodes);
    }
    function _containerInsertAfter(nodes) {
      return this._containerInsert(this.key + 1, nodes);
    }
    var last = (arr) => arr[arr.length - 1];
    function isHiddenInSequenceExpression(path) {
      return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
    }
    function isAlmostConstantAssignment(node2, scope) {
      if (!isAssignmentExpression(node2) || !isIdentifier3(node2.left)) {
        return false;
      }
      const blockScope = scope.getBlockParent();
      return blockScope.hasOwnBinding(node2.left.name) && blockScope.getOwnBinding(node2.left.name).constantViolations.length <= 1;
    }
    function insertAfter(nodes_) {
      this._assertUnremoved();
      if (this.isSequenceExpression()) {
        return last(this.get("expressions")).insertAfter(nodes_);
      }
      const nodes = this._verifyNodeList(nodes_);
      const {
        parentPath,
        parent
      } = this;
      if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration2(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
        return parentPath.insertAfter(nodes.map((node2) => {
          return isExpression(node2) ? expressionStatement(node2) : node2;
        }));
      } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
        if (this.node) {
          const node2 = this.node;
          let {
            scope
          } = this;
          if (scope.path.isPattern()) {
            assertExpression(node2);
            this.replaceWith(callExpression(arrowFunctionExpression([], node2), []));
            this.get("callee.body").insertAfter(nodes);
            return [this];
          }
          if (isHiddenInSequenceExpression(this)) {
            nodes.unshift(node2);
          } else if (isCallExpression2(node2) && isSuper(node2.callee)) {
            nodes.unshift(node2);
            nodes.push(thisExpression());
          } else if (isAlmostConstantAssignment(node2, scope)) {
            nodes.unshift(node2);
            nodes.push(cloneNode(node2.left));
          } else if (scope.isPure(node2, true)) {
            nodes.push(node2);
          } else {
            if (parentPath.isMethod({
              computed: true,
              key: node2
            })) {
              scope = scope.parent;
            }
            const temp = scope.generateDeclaredUidIdentifier();
            nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node2)));
            nodes.push(expressionStatement(cloneNode(temp)));
          }
        }
        return this.replaceExpressionWithStatements(nodes);
      } else if (Array.isArray(this.container)) {
        return this._containerInsertAfter(nodes);
      } else if (this.isStatementOrBlock()) {
        const node2 = this.node;
        const shouldInsertCurrentNode = node2 && (!this.isExpressionStatement() || node2.expression != null);
        this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node2] : []));
        return this.pushContainer("body", nodes);
      } else {
        throw new Error("We don't know what to do with this node type. We were previously a Statement but we can't fit in here?");
      }
    }
    function updateSiblingKeys(fromIndex, incrementBy) {
      if (!this.parent)
        return;
      const paths = _cache.path.get(this.parent);
      for (const [, path] of paths) {
        if (path.key >= fromIndex) {
          path.key += incrementBy;
        }
      }
    }
    function _verifyNodeList(nodes) {
      if (!nodes) {
        return [];
      }
      if (!Array.isArray(nodes)) {
        nodes = [nodes];
      }
      for (let i = 0; i < nodes.length; i++) {
        const node2 = nodes[i];
        let msg;
        if (!node2) {
          msg = "has falsy node";
        } else if (typeof node2 !== "object") {
          msg = "contains a non-object node";
        } else if (!node2.type) {
          msg = "without a type";
        } else if (node2 instanceof _index.default) {
          msg = "has a NodePath when it expected a raw object";
        }
        if (msg) {
          const type = Array.isArray(node2) ? "array" : typeof node2;
          throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
        }
      }
      return nodes;
    }
    function unshiftContainer(listKey, nodes) {
      this._assertUnremoved();
      nodes = this._verifyNodeList(nodes);
      const path = _index.default.get({
        parentPath: this,
        parent: this.node,
        container: this.node[listKey],
        listKey,
        key: 0
      }).setContext(this.context);
      return path._containerInsertBefore(nodes);
    }
    function pushContainer(listKey, nodes) {
      this._assertUnremoved();
      const verifiedNodes = this._verifyNodeList(nodes);
      const container = this.node[listKey];
      const path = _index.default.get({
        parentPath: this,
        parent: this.node,
        container,
        listKey,
        key: container.length
      }).setContext(this.context);
      return path.replaceWithMultiple(verifiedNodes);
    }
    function hoist(scope = this.scope) {
      const hoister = new _hoister.default(this, scope);
      return hoister.run();
    }
  }
});

// node_modules/@babel/traverse/lib/path/family.js
var require_family = __commonJS({
  "node_modules/@babel/traverse/lib/path/family.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._getKey = _getKey;
    exports._getPattern = _getPattern;
    exports.get = get;
    exports.getAllNextSiblings = getAllNextSiblings;
    exports.getAllPrevSiblings = getAllPrevSiblings;
    exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
    exports.getBindingIdentifiers = getBindingIdentifiers;
    exports.getCompletionRecords = getCompletionRecords;
    exports.getNextSibling = getNextSibling;
    exports.getOpposite = getOpposite;
    exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
    exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
    exports.getPrevSibling = getPrevSibling;
    exports.getSibling = getSibling;
    var _index = require_path();
    var _t = require_lib3();
    var {
      getBindingIdentifiers: _getBindingIdentifiers,
      getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
      isDeclaration: isDeclaration2,
      numericLiteral,
      unaryExpression
    } = _t;
    var NORMAL_COMPLETION = 0;
    var BREAK_COMPLETION = 1;
    function NormalCompletion(path) {
      return {
        type: NORMAL_COMPLETION,
        path
      };
    }
    function BreakCompletion(path) {
      return {
        type: BREAK_COMPLETION,
        path
      };
    }
    function getOpposite() {
      if (this.key === "left") {
        return this.getSibling("right");
      } else if (this.key === "right") {
        return this.getSibling("left");
      }
      return null;
    }
    function addCompletionRecords(path, records, context) {
      if (path) {
        records.push(..._getCompletionRecords(path, context));
      }
      return records;
    }
    function completionRecordForSwitch(cases, records, context) {
      let lastNormalCompletions = [];
      for (let i = 0; i < cases.length; i++) {
        const casePath = cases[i];
        const caseCompletions = _getCompletionRecords(casePath, context);
        const normalCompletions = [];
        const breakCompletions = [];
        for (const c2 of caseCompletions) {
          if (c2.type === NORMAL_COMPLETION) {
            normalCompletions.push(c2);
          }
          if (c2.type === BREAK_COMPLETION) {
            breakCompletions.push(c2);
          }
        }
        if (normalCompletions.length) {
          lastNormalCompletions = normalCompletions;
        }
        records.push(...breakCompletions);
      }
      records.push(...lastNormalCompletions);
      return records;
    }
    function normalCompletionToBreak(completions) {
      completions.forEach((c2) => {
        c2.type = BREAK_COMPLETION;
      });
    }
    function replaceBreakStatementInBreakCompletion(completions, reachable) {
      completions.forEach((c2) => {
        if (c2.path.isBreakStatement({
          label: null
        })) {
          if (reachable) {
            c2.path.replaceWith(unaryExpression("void", numericLiteral(0)));
          } else {
            c2.path.remove();
          }
        }
      });
    }
    function getStatementListCompletion(paths, context) {
      const completions = [];
      if (context.canHaveBreak) {
        let lastNormalCompletions = [];
        for (let i = 0; i < paths.length; i++) {
          const path = paths[i];
          const newContext = Object.assign({}, context, {
            inCaseClause: false
          });
          if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
            newContext.shouldPopulateBreak = true;
          } else {
            newContext.shouldPopulateBreak = false;
          }
          const statementCompletions = _getCompletionRecords(path, newContext);
          if (statementCompletions.length > 0 && statementCompletions.every((c2) => c2.type === BREAK_COMPLETION)) {
            if (lastNormalCompletions.length > 0 && statementCompletions.every((c2) => c2.path.isBreakStatement({
              label: null
            }))) {
              normalCompletionToBreak(lastNormalCompletions);
              completions.push(...lastNormalCompletions);
              if (lastNormalCompletions.some((c2) => c2.path.isDeclaration())) {
                completions.push(...statementCompletions);
                replaceBreakStatementInBreakCompletion(statementCompletions, true);
              }
              replaceBreakStatementInBreakCompletion(statementCompletions, false);
            } else {
              completions.push(...statementCompletions);
              if (!context.shouldPopulateBreak) {
                replaceBreakStatementInBreakCompletion(statementCompletions, true);
              }
            }
            break;
          }
          if (i === paths.length - 1) {
            completions.push(...statementCompletions);
          } else {
            lastNormalCompletions = [];
            for (let i2 = 0; i2 < statementCompletions.length; i2++) {
              const c2 = statementCompletions[i2];
              if (c2.type === BREAK_COMPLETION) {
                completions.push(c2);
              }
              if (c2.type === NORMAL_COMPLETION) {
                lastNormalCompletions.push(c2);
              }
            }
          }
        }
      } else if (paths.length) {
        for (let i = paths.length - 1; i >= 0; i--) {
          const pathCompletions = _getCompletionRecords(paths[i], context);
          if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) {
            completions.push(...pathCompletions);
            break;
          }
        }
      }
      return completions;
    }
    function _getCompletionRecords(path, context) {
      let records = [];
      if (path.isIfStatement()) {
        records = addCompletionRecords(path.get("consequent"), records, context);
        records = addCompletionRecords(path.get("alternate"), records, context);
      } else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) {
        return addCompletionRecords(path.get("body"), records, context);
      } else if (path.isProgram() || path.isBlockStatement()) {
        return getStatementListCompletion(path.get("body"), context);
      } else if (path.isFunction()) {
        return _getCompletionRecords(path.get("body"), context);
      } else if (path.isTryStatement()) {
        records = addCompletionRecords(path.get("block"), records, context);
        records = addCompletionRecords(path.get("handler"), records, context);
      } else if (path.isCatchClause()) {
        return addCompletionRecords(path.get("body"), records, context);
      } else if (path.isSwitchStatement()) {
        return completionRecordForSwitch(path.get("cases"), records, context);
      } else if (path.isSwitchCase()) {
        return getStatementListCompletion(path.get("consequent"), {
          canHaveBreak: true,
          shouldPopulateBreak: false,
          inCaseClause: true
        });
      } else if (path.isBreakStatement()) {
        records.push(BreakCompletion(path));
      } else {
        records.push(NormalCompletion(path));
      }
      return records;
    }
    function getCompletionRecords() {
      const records = _getCompletionRecords(this, {
        canHaveBreak: false,
        shouldPopulateBreak: false,
        inCaseClause: false
      });
      return records.map((r) => r.path);
    }
    function getSibling(key2) {
      return _index.default.get({
        parentPath: this.parentPath,
        parent: this.parent,
        container: this.container,
        listKey: this.listKey,
        key: key2
      }).setContext(this.context);
    }
    function getPrevSibling() {
      return this.getSibling(this.key - 1);
    }
    function getNextSibling() {
      return this.getSibling(this.key + 1);
    }
    function getAllNextSiblings() {
      let _key = this.key;
      let sibling = this.getSibling(++_key);
      const siblings = [];
      while (sibling.node) {
        siblings.push(sibling);
        sibling = this.getSibling(++_key);
      }
      return siblings;
    }
    function getAllPrevSiblings() {
      let _key = this.key;
      let sibling = this.getSibling(--_key);
      const siblings = [];
      while (sibling.node) {
        siblings.push(sibling);
        sibling = this.getSibling(--_key);
      }
      return siblings;
    }
    function get(key2, context = true) {
      if (context === true)
        context = this.context;
      const parts = key2.split(".");
      if (parts.length === 1) {
        return this._getKey(key2, context);
      } else {
        return this._getPattern(parts, context);
      }
    }
    function _getKey(key2, context) {
      const node2 = this.node;
      const container = node2[key2];
      if (Array.isArray(container)) {
        return container.map((_, i) => {
          return _index.default.get({
            listKey: key2,
            parentPath: this,
            parent: node2,
            container,
            key: i
          }).setContext(context);
        });
      } else {
        return _index.default.get({
          parentPath: this,
          parent: node2,
          container: node2,
          key: key2
        }).setContext(context);
      }
    }
    function _getPattern(parts, context) {
      let path = this;
      for (const part of parts) {
        if (part === ".") {
          path = path.parentPath;
        } else {
          if (Array.isArray(path)) {
            path = path[part];
          } else {
            path = path.get(part, context);
          }
        }
      }
      return path;
    }
    function getBindingIdentifiers(duplicates) {
      return _getBindingIdentifiers(this.node, duplicates);
    }
    function getOuterBindingIdentifiers(duplicates) {
      return _getOuterBindingIdentifiers(this.node, duplicates);
    }
    function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
      const path = this;
      const search2 = [path];
      const ids = /* @__PURE__ */ Object.create(null);
      while (search2.length) {
        const id = search2.shift();
        if (!id)
          continue;
        if (!id.node)
          continue;
        const keys2 = _getBindingIdentifiers.keys[id.node.type];
        if (id.isIdentifier()) {
          if (duplicates) {
            const _ids = ids[id.node.name] = ids[id.node.name] || [];
            _ids.push(id);
          } else {
            ids[id.node.name] = id;
          }
          continue;
        }
        if (id.isExportDeclaration()) {
          const declaration = id.get("declaration");
          if (isDeclaration2(declaration)) {
            search2.push(declaration);
          }
          continue;
        }
        if (outerOnly) {
          if (id.isFunctionDeclaration()) {
            search2.push(id.get("id"));
            continue;
          }
          if (id.isFunctionExpression()) {
            continue;
          }
        }
        if (keys2) {
          for (let i = 0; i < keys2.length; i++) {
            const key2 = keys2[i];
            const child = id.get(key2);
            if (Array.isArray(child)) {
              search2.push(...child);
            } else if (child.node) {
              search2.push(child);
            }
          }
        }
      }
      return ids;
    }
    function getOuterBindingIdentifierPaths(duplicates = false) {
      return this.getBindingIdentifierPaths(duplicates, true);
    }
  }
});

// node_modules/@babel/traverse/lib/path/comments.js
var require_comments = __commonJS({
  "node_modules/@babel/traverse/lib/path/comments.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.addComment = addComment;
    exports.addComments = addComments;
    exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
    var _t = require_lib3();
    var {
      addComment: _addComment,
      addComments: _addComments
    } = _t;
    function shareCommentsWithSiblings() {
      if (typeof this.key === "string")
        return;
      const node2 = this.node;
      if (!node2)
        return;
      const trailing = node2.trailingComments;
      const leading = node2.leadingComments;
      if (!trailing && !leading)
        return;
      const prev = this.getSibling(this.key - 1);
      const next = this.getSibling(this.key + 1);
      const hasPrev = Boolean(prev.node);
      const hasNext = Boolean(next.node);
      if (hasPrev) {
        if (leading) {
          prev.addComments("trailing", removeIfExisting(leading, prev.node.trailingComments));
        }
        if (trailing && !hasNext)
          prev.addComments("trailing", trailing);
      }
      if (hasNext) {
        if (trailing) {
          next.addComments("leading", removeIfExisting(trailing, next.node.leadingComments));
        }
        if (leading && !hasPrev)
          next.addComments("leading", leading);
      }
    }
    function removeIfExisting(list3, toRemove) {
      if (!toRemove)
        return list3;
      let lastFoundIndex = -1;
      return list3.filter((el) => {
        const i = toRemove.indexOf(el, lastFoundIndex);
        if (i === -1)
          return true;
        lastFoundIndex = i;
      });
    }
    function addComment(type, content3, line2) {
      _addComment(this.node, type, content3, line2);
    }
    function addComments(type, comments) {
      _addComments(this.node, type, comments);
    }
  }
});

// node_modules/@babel/traverse/lib/path/lib/virtual-types-validator.js
var require_virtual_types_validator = __commonJS({
  "node_modules/@babel/traverse/lib/path/lib/virtual-types-validator.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isBindingIdentifier = isBindingIdentifier;
    exports.isBlockScoped = isBlockScoped;
    exports.isExistentialTypeParam = isExistentialTypeParam;
    exports.isExpression = isExpression;
    exports.isFlow = isFlow;
    exports.isForAwaitStatement = isForAwaitStatement;
    exports.isGenerated = isGenerated;
    exports.isNumericLiteralTypeAnnotation = isNumericLiteralTypeAnnotation;
    exports.isPure = isPure;
    exports.isReferenced = isReferenced;
    exports.isReferencedIdentifier = isReferencedIdentifier;
    exports.isReferencedMemberExpression = isReferencedMemberExpression;
    exports.isRestProperty = isRestProperty;
    exports.isScope = isScope;
    exports.isSpreadProperty = isSpreadProperty;
    exports.isStatement = isStatement;
    exports.isUser = isUser;
    exports.isVar = isVar;
    var _t = require_lib3();
    var {
      isBinding,
      isBlockScoped: nodeIsBlockScoped,
      isExportDeclaration,
      isExpression: nodeIsExpression,
      isFlow: nodeIsFlow,
      isForStatement,
      isForXStatement,
      isIdentifier: isIdentifier3,
      isImportDeclaration,
      isImportSpecifier,
      isJSXIdentifier: isJSXIdentifier3,
      isJSXMemberExpression,
      isMemberExpression: isMemberExpression2,
      isRestElement: nodeIsRestElement,
      isReferenced: nodeIsReferenced,
      isScope: nodeIsScope,
      isStatement: nodeIsStatement,
      isVar: nodeIsVar,
      isVariableDeclaration: isVariableDeclaration2,
      react,
      isForOfStatement
    } = _t;
    var {
      isCompatTag
    } = react;
    function isReferencedIdentifier(opts) {
      const {
        node: node2,
        parent
      } = this;
      if (!isIdentifier3(node2, opts) && !isJSXMemberExpression(parent, opts)) {
        if (isJSXIdentifier3(node2, opts)) {
          if (isCompatTag(node2.name))
            return false;
        } else {
          return false;
        }
      }
      return nodeIsReferenced(node2, parent, this.parentPath.parent);
    }
    function isReferencedMemberExpression() {
      const {
        node: node2,
        parent
      } = this;
      return isMemberExpression2(node2) && nodeIsReferenced(node2, parent);
    }
    function isBindingIdentifier() {
      const {
        node: node2,
        parent
      } = this;
      const grandparent = this.parentPath.parent;
      return isIdentifier3(node2) && isBinding(node2, parent, grandparent);
    }
    function isStatement() {
      const {
        node: node2,
        parent
      } = this;
      if (nodeIsStatement(node2)) {
        if (isVariableDeclaration2(node2)) {
          if (isForXStatement(parent, {
            left: node2
          }))
            return false;
          if (isForStatement(parent, {
            init: node2
          }))
            return false;
        }
        return true;
      } else {
        return false;
      }
    }
    function isExpression() {
      if (this.isIdentifier()) {
        return this.isReferencedIdentifier();
      } else {
        return nodeIsExpression(this.node);
      }
    }
    function isScope() {
      return nodeIsScope(this.node, this.parent);
    }
    function isReferenced() {
      return nodeIsReferenced(this.node, this.parent);
    }
    function isBlockScoped() {
      return nodeIsBlockScoped(this.node);
    }
    function isVar() {
      return nodeIsVar(this.node);
    }
    function isUser() {
      return this.node && !!this.node.loc;
    }
    function isGenerated() {
      return !this.isUser();
    }
    function isPure(constantsOnly) {
      return this.scope.isPure(this.node, constantsOnly);
    }
    function isFlow() {
      const {
        node: node2
      } = this;
      if (nodeIsFlow(node2)) {
        return true;
      } else if (isImportDeclaration(node2)) {
        return node2.importKind === "type" || node2.importKind === "typeof";
      } else if (isExportDeclaration(node2)) {
        return node2.exportKind === "type";
      } else if (isImportSpecifier(node2)) {
        return node2.importKind === "type" || node2.importKind === "typeof";
      } else {
        return false;
      }
    }
    function isRestProperty() {
      return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
    }
    function isSpreadProperty() {
      return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
    }
    function isForAwaitStatement() {
      return isForOfStatement(this.node, {
        await: true
      });
    }
    function isExistentialTypeParam() {
      throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.");
    }
    function isNumericLiteralTypeAnnotation() {
      throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.");
    }
  }
});

// node_modules/@babel/traverse/lib/path/index.js
var require_path = __commonJS({
  "node_modules/@babel/traverse/lib/path/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
    var virtualTypes = require_virtual_types();
    var _debug = require_src();
    var _index = require_lib13();
    var _scope = require_scope();
    var _t = require_lib3();
    var t3 = _t;
    var _cache = require_cache();
    var _generator = require_lib4();
    var NodePath_ancestry = require_ancestry();
    var NodePath_inference = require_inference();
    var NodePath_replacement = require_replacement();
    var NodePath_evaluation = require_evaluation();
    var NodePath_conversion = require_conversion();
    var NodePath_introspection = require_introspection();
    var NodePath_context = require_context();
    var NodePath_removal = require_removal();
    var NodePath_modification = require_modification();
    var NodePath_family = require_family();
    var NodePath_comments = require_comments();
    var NodePath_virtual_types_validator = require_virtual_types_validator();
    var {
      validate
    } = _t;
    var debug = _debug("babel");
    var REMOVED = 1 << 0;
    exports.REMOVED = REMOVED;
    var SHOULD_STOP = 1 << 1;
    exports.SHOULD_STOP = SHOULD_STOP;
    var SHOULD_SKIP = 1 << 2;
    exports.SHOULD_SKIP = SHOULD_SKIP;
    var NodePath = class {
      constructor(hub, parent) {
        this.contexts = [];
        this.state = null;
        this.opts = null;
        this._traverseFlags = 0;
        this.skipKeys = null;
        this.parentPath = null;
        this.container = null;
        this.listKey = null;
        this.key = null;
        this.node = null;
        this.type = null;
        this.parent = parent;
        this.hub = hub;
        this.data = null;
        this.context = null;
        this.scope = null;
      }
      static get({
        hub,
        parentPath,
        parent,
        container,
        listKey,
        key: key2
      }) {
        if (!hub && parentPath) {
          hub = parentPath.hub;
        }
        if (!parent) {
          throw new Error("To get a node path the parent needs to exist");
        }
        const targetNode = container[key2];
        let paths = _cache.path.get(parent);
        if (!paths) {
          paths = /* @__PURE__ */ new Map();
          _cache.path.set(parent, paths);
        }
        let path = paths.get(targetNode);
        if (!path) {
          path = new NodePath(hub, parent);
          if (targetNode)
            paths.set(targetNode, path);
        }
        path.setup(parentPath, container, listKey, key2);
        return path;
      }
      getScope(scope) {
        return this.isScope() ? new _scope.default(this) : scope;
      }
      setData(key2, val) {
        if (this.data == null) {
          this.data = /* @__PURE__ */ Object.create(null);
        }
        return this.data[key2] = val;
      }
      getData(key2, def) {
        if (this.data == null) {
          this.data = /* @__PURE__ */ Object.create(null);
        }
        let val = this.data[key2];
        if (val === void 0 && def !== void 0)
          val = this.data[key2] = def;
        return val;
      }
      hasNode() {
        return this.node != null;
      }
      buildCodeFrameError(msg, Error2 = SyntaxError) {
        return this.hub.buildError(this.node, msg, Error2);
      }
      traverse(visitor, state) {
        (0, _index.default)(this.node, visitor, this.scope, state, this);
      }
      set(key2, node2) {
        validate(this.node, key2, node2);
        this.node[key2] = node2;
      }
      getPathLocation() {
        const parts = [];
        let path = this;
        do {
          let key2 = path.key;
          if (path.inList)
            key2 = `${path.listKey}[${key2}]`;
          parts.unshift(key2);
        } while (path = path.parentPath);
        return parts.join(".");
      }
      debug(message) {
        if (!debug.enabled)
          return;
        debug(`${this.getPathLocation()} ${this.type}: ${message}`);
      }
      toString() {
        return (0, _generator.default)(this.node).code;
      }
      get inList() {
        return !!this.listKey;
      }
      set inList(inList) {
        if (!inList) {
          this.listKey = null;
        }
      }
      get parentKey() {
        return this.listKey || this.key;
      }
      get shouldSkip() {
        return !!(this._traverseFlags & SHOULD_SKIP);
      }
      set shouldSkip(v) {
        if (v) {
          this._traverseFlags |= SHOULD_SKIP;
        } else {
          this._traverseFlags &= ~SHOULD_SKIP;
        }
      }
      get shouldStop() {
        return !!(this._traverseFlags & SHOULD_STOP);
      }
      set shouldStop(v) {
        if (v) {
          this._traverseFlags |= SHOULD_STOP;
        } else {
          this._traverseFlags &= ~SHOULD_STOP;
        }
      }
      get removed() {
        return !!(this._traverseFlags & REMOVED);
      }
      set removed(v) {
        if (v) {
          this._traverseFlags |= REMOVED;
        } else {
          this._traverseFlags &= ~REMOVED;
        }
      }
    };
    Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
    {
      NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
    }
    for (const type of t3.TYPES) {
      const typeKey = `is${type}`;
      const fn = t3[typeKey];
      NodePath.prototype[typeKey] = function(opts) {
        return fn(this.node, opts);
      };
      NodePath.prototype[`assert${type}`] = function(opts) {
        if (!fn(this.node, opts)) {
          throw new TypeError(`Expected node path of type ${type}`);
        }
      };
    }
    Object.assign(NodePath.prototype, NodePath_virtual_types_validator);
    for (const type of Object.keys(virtualTypes)) {
      if (type[0] === "_")
        continue;
      if (!t3.TYPES.includes(type))
        t3.TYPES.push(type);
    }
    var _default = NodePath;
    exports.default = _default;
  }
});

// node_modules/@babel/traverse/lib/context.js
var require_context2 = __commonJS({
  "node_modules/@babel/traverse/lib/context.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _path = require_path();
    var _t = require_lib3();
    var {
      VISITOR_KEYS
    } = _t;
    var TraversalContext = class {
      constructor(scope, opts, state, parentPath) {
        this.queue = null;
        this.priorityQueue = null;
        this.parentPath = parentPath;
        this.scope = scope;
        this.state = state;
        this.opts = opts;
      }
      shouldVisit(node2) {
        const opts = this.opts;
        if (opts.enter || opts.exit)
          return true;
        if (opts[node2.type])
          return true;
        const keys2 = VISITOR_KEYS[node2.type];
        if (!(keys2 != null && keys2.length))
          return false;
        for (const key2 of keys2) {
          if (node2[key2]) {
            return true;
          }
        }
        return false;
      }
      create(node2, container, key2, listKey) {
        return _path.default.get({
          parentPath: this.parentPath,
          parent: node2,
          container,
          key: key2,
          listKey
        });
      }
      maybeQueue(path, notPriority) {
        if (this.queue) {
          if (notPriority) {
            this.queue.push(path);
          } else {
            this.priorityQueue.push(path);
          }
        }
      }
      visitMultiple(container, parent, listKey) {
        if (container.length === 0)
          return false;
        const queue = [];
        for (let key2 = 0; key2 < container.length; key2++) {
          const node2 = container[key2];
          if (node2 && this.shouldVisit(node2)) {
            queue.push(this.create(parent, container, key2, listKey));
          }
        }
        return this.visitQueue(queue);
      }
      visitSingle(node2, key2) {
        if (this.shouldVisit(node2[key2])) {
          return this.visitQueue([this.create(node2, node2, key2)]);
        } else {
          return false;
        }
      }
      visitQueue(queue) {
        this.queue = queue;
        this.priorityQueue = [];
        const visited = /* @__PURE__ */ new WeakSet();
        let stop = false;
        for (const path of queue) {
          path.resync();
          if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
            path.pushContext(this);
          }
          if (path.key === null)
            continue;
          const {
            node: node2
          } = path;
          if (visited.has(node2))
            continue;
          if (node2)
            visited.add(node2);
          if (path.visit()) {
            stop = true;
            break;
          }
          if (this.priorityQueue.length) {
            stop = this.visitQueue(this.priorityQueue);
            this.priorityQueue = [];
            this.queue = queue;
            if (stop)
              break;
          }
        }
        for (const path of queue) {
          path.popContext();
        }
        this.queue = null;
        return stop;
      }
      visit(node2, key2) {
        const nodes = node2[key2];
        if (!nodes)
          return false;
        if (Array.isArray(nodes)) {
          return this.visitMultiple(nodes, node2, key2);
        } else {
          return this.visitSingle(node2, key2);
        }
      }
    };
    exports.default = TraversalContext;
  }
});

// node_modules/@babel/traverse/lib/traverse-node.js
var require_traverse_node = __commonJS({
  "node_modules/@babel/traverse/lib/traverse-node.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.traverseNode = traverseNode;
    var _context = require_context2();
    var _t = require_lib3();
    var {
      VISITOR_KEYS
    } = _t;
    function traverseNode(node2, opts, scope, state, path, skipKeys) {
      const keys2 = VISITOR_KEYS[node2.type];
      if (!keys2)
        return false;
      const context = new _context.default(scope, opts, state, path);
      for (const key2 of keys2) {
        if (skipKeys && skipKeys[key2])
          continue;
        if (context.visit(node2, key2)) {
          return true;
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/traverse/lib/hub.js
var require_hub = __commonJS({
  "node_modules/@babel/traverse/lib/hub.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var Hub = class {
      getCode() {
      }
      getScope() {
      }
      addHelper() {
        throw new Error("Helpers are not supported by the default hub.");
      }
      buildError(node2, msg, Error2 = TypeError) {
        return new Error2(msg);
      }
    };
    exports.default = Hub;
  }
});

// node_modules/@babel/traverse/lib/index.js
var require_lib13 = __commonJS({
  "node_modules/@babel/traverse/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "Hub", {
      enumerable: true,
      get: function() {
        return _hub.default;
      }
    });
    Object.defineProperty(exports, "NodePath", {
      enumerable: true,
      get: function() {
        return _path.default;
      }
    });
    Object.defineProperty(exports, "Scope", {
      enumerable: true,
      get: function() {
        return _scope.default;
      }
    });
    exports.visitors = exports.default = void 0;
    var visitors = require_visitors();
    exports.visitors = visitors;
    var _t = require_lib3();
    var cache = require_cache();
    var _traverseNode = require_traverse_node();
    var _path = require_path();
    var _scope = require_scope();
    var _hub = require_hub();
    var {
      VISITOR_KEYS,
      removeProperties,
      traverseFast
    } = _t;
    function traverse(parent, opts = {}, scope, state, parentPath) {
      if (!parent)
        return;
      if (!opts.noScope && !scope) {
        if (parent.type !== "Program" && parent.type !== "File") {
          throw new Error(`You must pass a scope and parentPath unless traversing a Program/File. Instead of that you tried to traverse a ${parent.type} node without passing scope and parentPath.`);
        }
      }
      if (!VISITOR_KEYS[parent.type]) {
        return;
      }
      visitors.explode(opts);
      (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath);
    }
    var _default = traverse;
    exports.default = _default;
    traverse.visitors = visitors;
    traverse.verify = visitors.verify;
    traverse.explode = visitors.explode;
    traverse.cheap = function(node2, enter) {
      traverseFast(node2, enter);
      return;
    };
    traverse.node = function(node2, opts, scope, state, path, skipKeys) {
      (0, _traverseNode.traverseNode)(node2, opts, scope, state, path, skipKeys);
    };
    traverse.clearNode = function(node2, opts) {
      removeProperties(node2, opts);
      cache.path.delete(node2);
    };
    traverse.removeProperties = function(tree, opts) {
      traverseFast(tree, traverse.clearNode, opts);
      return tree;
    };
    function hasDenylistedType(path, state) {
      if (path.node.type === state.type) {
        state.has = true;
        path.stop();
      }
    }
    traverse.hasType = function(tree, type, denylistTypes) {
      if (denylistTypes != null && denylistTypes.includes(tree.type))
        return false;
      if (tree.type === type)
        return true;
      const state = {
        has: false,
        type
      };
      traverse(tree, {
        noScope: true,
        denylist: denylistTypes,
        enter: hasDenylistedType
      }, null, state);
      return state.has;
    };
    traverse.cache = cache;
  }
});

// node_modules/estree-to-babel/lib/traverse-object-expression.js
var require_traverse_object_expression = __commonJS({
  "node_modules/estree-to-babel/lib/traverse-object-expression.js"(exports, module2) {
    "use strict";
    var { assign } = Object;
    var {
      isFunctionExpression,
      ObjectMethod
    } = require_lib3();
    module2.exports = (propertiesPaths) => {
      for (const propPath of propertiesPaths) {
        const {
          computed,
          key: key2,
          value: value2
        } = propPath.node;
        if (isFunctionExpression(value2)) {
          propPath.replaceWith(ObjectMethod("method", key2, value2.params, value2.body, computed));
          assign(propPath.node, {
            id: null,
            method: true,
            generator: value2.generator,
            loc: getObjectMethodLoc(key2, value2),
            async: value2.async,
            type: "ObjectMethod"
          });
        }
      }
    };
    function getObjectMethodLoc(key2, value2) {
      return {
        start: key2.loc.start,
        end: value2.loc.end
      };
    }
  }
});

// node_modules/estree-to-babel/lib/set-class-method.js
var require_set_class_method = __commonJS({
  "node_modules/estree-to-babel/lib/set-class-method.js"(exports, module2) {
    "use strict";
    var {
      isPrivateName,
      classPrivateMethod,
      classMethod
    } = require_lib3();
    var { assign } = Object;
    module2.exports = (path) => {
      const { node: node2 } = path;
      const {
        key: key2,
        kind,
        computed,
        loc
      } = node2;
      const {
        body,
        params,
        expression,
        generator
      } = node2.value;
      const method = getClassMethod({
        kind,
        key: key2,
        params,
        body,
        computed,
        nodeStatic: node2.static
      });
      path.replaceWith(method);
      assign(path.node, {
        loc,
        expression,
        generator
      });
    };
    function getClassMethod({ kind, key: key2, params, body, computed, nodeStatic }) {
      if (isPrivateName(key2))
        return classPrivateMethod(
          kind,
          key2,
          params,
          body,
          computed
        );
      return classMethod(
        kind,
        key2,
        params,
        body,
        computed,
        nodeStatic
      );
    }
  }
});

// node_modules/estree-to-babel/lib/set-class-private-property.js
var require_set_class_private_property = __commonJS({
  "node_modules/estree-to-babel/lib/set-class-private-property.js"(exports, module2) {
    "use strict";
    module2.exports = (path) => {
      path.node.type = "ClassPrivateProperty";
    };
  }
});

// node_modules/estree-to-babel/lib/set-class-private-name.js
var require_set_class_private_name = __commonJS({
  "node_modules/estree-to-babel/lib/set-class-private-name.js"(exports, module2) {
    "use strict";
    var { Identifier } = require_lib3();
    module2.exports = (path) => {
      const { node: node2 } = path;
      if (!node2.name)
        return;
      node2.id = Identifier(node2.name);
      delete node2.name;
    };
  }
});

// node_modules/estree-to-babel/lib/set-literal.js
var require_set_literal = __commonJS({
  "node_modules/estree-to-babel/lib/set-literal.js"(exports, module2) {
    "use strict";
    var isString = (a) => typeof a === "string";
    var isNumber = (a) => typeof a === "number";
    var isNull = (a) => a === null;
    var isBool = (a) => typeof a === "boolean";
    module2.exports = (node2) => {
      const { type, value: value2 } = node2;
      if (type !== "Literal")
        return;
      if (isNull(value2)) {
        node2.type = "NullLiteral";
        return;
      }
      if (isString(value2)) {
        node2.type = "StringLiteral";
        return;
      }
      if (isNumber(value2)) {
        node2.type = "NumericLiteral";
        return;
      }
      if (isBool(value2)) {
        node2.type = "BooleanLiteral";
        return;
      }
      if (node2.regex) {
        transformRegExp(node2);
        return;
      }
    };
    function transformRegExp(node2) {
      node2.type = "RegExpLiteral";
      for (const key2 of Object.keys(node2.regex)) {
        node2[key2] = node2.regex[key2];
      }
      delete node2.regex;
    }
  }
});

// node_modules/estree-to-babel/lib/convert-import-to-call.js
var require_convert_import_to_call = __commonJS({
  "node_modules/estree-to-babel/lib/convert-import-to-call.js"(exports, module2) {
    "use strict";
    var {
      CallExpression,
      Identifier
    } = require_lib3();
    var setLiteral = require_set_literal();
    module2.exports = (path) => {
      const { source: source2 } = path.node;
      setLiteral(source2);
      const callNode = CallExpression(Identifier("import"), [
        source2
      ]);
      path.replaceWith(callNode);
    };
  }
});

// node_modules/estree-to-babel/lib/convert-chain-expression.js
var require_convert_chain_expression = __commonJS({
  "node_modules/estree-to-babel/lib/convert-chain-expression.js"(exports, module2) {
    "use strict";
    module2.exports = (path) => {
      const expressionPath = path.get("expression");
      const { expression } = path.node;
      if (expressionPath.isCallExpression())
        expression.stype = "OptionalCallExpression";
      else
        expression.type = "OptionalMemberExpression";
      path.replaceWith(expression);
    };
  }
});

// node_modules/estree-to-babel/lib/convert-import-declaration.js
var require_convert_import_declaration = __commonJS({
  "node_modules/estree-to-babel/lib/convert-import-declaration.js"(exports, module2) {
    "use strict";
    module2.exports = (path) => {
      const { assertions = [] } = path.node;
      path.node.assertions = assertions;
    };
  }
});

// node_modules/estree-to-babel/lib/convert-export-declaration.js
var require_convert_export_declaration = __commonJS({
  "node_modules/estree-to-babel/lib/convert-export-declaration.js"(exports, module2) {
    "use strict";
    var { assign } = Object;
    module2.exports = (path) => {
      const { assertions = [] } = path.node;
      assign(path.node, {
        assertions
      });
    };
  }
});

// node_modules/estree-to-babel/lib/ts.js
var require_ts = __commonJS({
  "node_modules/estree-to-babel/lib/ts.js"(exports, module2) {
    "use strict";
    module2.exports.convertTSClassImplements = (path) => {
      path.node.type = "TSExpressionWithTypeArguments";
    };
    module2.exports.convertPropertyDefinition = (path) => {
      const { node: node2 } = path;
      if (node2.key.type === "PrivateIdentifier") {
        const { key: key2 } = node2;
        node2.type = "ClassPrivateProperty";
        node2.key = createPrivateName(key2);
        return;
      }
      path.node.type = "ClassProperty";
    };
    module2.exports.convertTSInterfaceHeritage = (path) => {
      path.node.type = "TSExpressionWithTypeArguments";
      let { expression } = path.node;
      while (expression.type === "MemberExpression") {
        const { object, property } = expression;
        expression.type = "TSQualifiedName";
        expression.left = object;
        expression.right = property;
        delete expression.object;
        delete expression.property;
        expression = object;
      }
    };
    module2.exports.convertPrivateIdentifier = (path) => {
      path.replaceWith(createPrivateName(path.node));
    };
    module2.exports.convertTSAbstractMethodDefinition = (path) => {
      const { node: node2 } = path;
      const {
        generator,
        async,
        params,
        id,
        returnType
      } = node2.value;
      const newNode = {
        ...node2,
        abstract: true,
        generator,
        async,
        params,
        id,
        returnType,
        type: "TSDeclareMethod"
      };
      delete newNode.value;
      path.replaceWith(newNode);
    };
    function createPrivateName(node2) {
      return {
        type: "PrivateName",
        id: {
          ...node2,
          type: "Identifier"
        }
      };
    }
  }
});

// node_modules/estree-to-babel/lib/comments.js
var require_comments2 = __commonJS({
  "node_modules/estree-to-babel/lib/comments.js"(exports, module2) {
    "use strict";
    module2.exports.convertNodeComments = (node2) => {
      const { comments } = node2;
      if (!comments)
        return;
      delete node2.comments;
      node2.leadingComments = void 0;
      node2.trailingComments = void 0;
      node2.innerComments = void 0;
      for (const comment2 of comments) {
        const group = getCommentGroup(comment2);
        if (!node2[group])
          node2[group] = [];
        delete comment2.leading;
        delete comment2.trailing;
        comment2.type = getCommentType(comment2);
        node2[group].push(comment2);
      }
    };
    module2.exports.convertProgramComments = (comments) => {
      for (const comment2 of comments) {
        comment2.type = getCommentType(comment2);
      }
      return comments;
    };
    function getCommentType({ type }) {
      return `Comment${type}`;
    }
    function getCommentGroup({ trailing, leading }) {
      if (trailing)
        return "trailingComments";
      if (leading)
        return "leadingComments";
      return "innerComments";
    }
  }
});

// node_modules/estree-to-babel/lib/get-ast.js
var require_get_ast = __commonJS({
  "node_modules/estree-to-babel/lib/get-ast.js"(exports, module2) {
    "use strict";
    var { convertProgramComments } = require_comments2();
    module2.exports = (node2) => {
      if (node2.type === "File")
        return node2;
      const {
        comments = [],
        tokens,
        ...program
      } = node2;
      const ast = {
        type: "File",
        program: {
          ...program,
          directives: []
        },
        comments: convertProgramComments(comments),
        tokens
      };
      return ast;
    };
  }
});

// node_modules/estree-to-babel/lib/estree-to-babel.js
var require_estree_to_babel = __commonJS({
  "node_modules/estree-to-babel/lib/estree-to-babel.js"(exports, module2) {
    "use strict";
    var traverse = require_lib13().default;
    var {
      isObjectExpression: isObjectExpression2,
      isExportDeclaration
    } = require_lib3();
    var traverseObjectExpression = require_traverse_object_expression();
    var setClassMethod = require_set_class_method();
    var setClassPrivateProperty = require_set_class_private_property();
    var setClassPrivateName = require_set_class_private_name();
    var convertImportToCall = require_convert_import_to_call();
    var convertChainExpression = require_convert_chain_expression();
    var convertImportDeclaration = require_convert_import_declaration();
    var convertExportDeclaration = require_convert_export_declaration();
    var {
      convertTSClassImplements,
      convertTSInterfaceHeritage,
      convertTSAbstractMethodDefinition,
      convertPropertyDefinition,
      convertPrivateIdentifier
    } = require_ts();
    var { convertNodeComments } = require_comments2();
    var setLiteral = require_set_literal();
    var getAST = require_get_ast();
    module2.exports = (node2) => {
      const ast = getAST(node2);
      traverse(ast, {
        noScope: true,
        enter(path) {
          const { node: node3 } = path;
          const { type } = node3;
          if (/Literal$/.test(type)) {
            setLiteral(node3);
            return setEsprimaRaw(node3);
          }
          if (type === "Property")
            return setObjectProperty(node3);
          if (type === "MethodDefinition")
            return setClassMethod(path);
          if (type === "FieldDefinition")
            return setClassPrivateProperty(path);
          if (type === "PrivateName")
            return setClassPrivateName(path);
          if (type === "ImportExpression")
            return convertImportToCall(path);
          if (type === "ImportDeclaration")
            return convertImportDeclaration(path);
          if (isExportDeclaration(path))
            return convertExportDeclaration(path);
          if (type === "ChainExpression")
            return convertChainExpression(path);
          if (type === "TSAbstractMethodDefinition")
            return convertTSAbstractMethodDefinition(path);
          if (type === "TSInterfaceHeritage")
            return convertTSInterfaceHeritage(path);
          if (type === "PropertyDefinition")
            return convertPropertyDefinition(path);
          if (type === "PrivateIdentifier")
            return convertPrivateIdentifier(path);
          if (type === "TSClassImplements")
            return convertTSClassImplements(path);
        },
        exit(path) {
          const { node: node3 } = path;
          convertNodeComments(node3);
          if (isObjectExpression2(node3))
            return traverseObjectExpression(path.get("properties"));
        }
      });
      return ast;
    };
    function setObjectProperty(node2) {
      node2.type = "ObjectProperty";
    }
    function setEsprimaRaw(node2) {
      const { raw } = node2;
      node2.raw = raw || node2.extra?.raw;
      node2.extra = node2.extra || {
        raw
      };
    }
  }
});

// node_modules/lodash/_arrayMap.js
var require_arrayMap = __commonJS({
  "node_modules/lodash/_arrayMap.js"(exports, module2) {
    function arrayMap(array, iteratee) {
      var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
      while (++index2 < length) {
        result[index2] = iteratee(array[index2], index2, array);
      }
      return result;
    }
    module2.exports = arrayMap;
  }
});

// node_modules/lodash/isSymbol.js
var require_isSymbol = __commonJS({
  "node_modules/lodash/isSymbol.js"(exports, module2) {
    var baseGetTag = require_baseGetTag();
    var isObjectLike = require_isObjectLike();
    var symbolTag = "[object Symbol]";
    function isSymbol(value2) {
      return typeof value2 == "symbol" || isObjectLike(value2) && baseGetTag(value2) == symbolTag;
    }
    module2.exports = isSymbol;
  }
});

// node_modules/lodash/_baseToString.js
var require_baseToString = __commonJS({
  "node_modules/lodash/_baseToString.js"(exports, module2) {
    var Symbol2 = require_Symbol();
    var arrayMap = require_arrayMap();
    var isArray3 = require_isArray();
    var isSymbol = require_isSymbol();
    var INFINITY = 1 / 0;
    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
    var symbolToString = symbolProto ? symbolProto.toString : void 0;
    function baseToString(value2) {
      if (typeof value2 == "string") {
        return value2;
      }
      if (isArray3(value2)) {
        return arrayMap(value2, baseToString) + "";
      }
      if (isSymbol(value2)) {
        return symbolToString ? symbolToString.call(value2) : "";
      }
      var result = value2 + "";
      return result == "0" && 1 / value2 == -INFINITY ? "-0" : result;
    }
    module2.exports = baseToString;
  }
});

// node_modules/lodash/toString.js
var require_toString = __commonJS({
  "node_modules/lodash/toString.js"(exports, module2) {
    var baseToString = require_baseToString();
    function toString4(value2) {
      return value2 == null ? "" : baseToString(value2);
    }
    module2.exports = toString4;
  }
});

// node_modules/lodash/_baseSlice.js
var require_baseSlice = __commonJS({
  "node_modules/lodash/_baseSlice.js"(exports, module2) {
    function baseSlice(array, start3, end) {
      var index2 = -1, length = array.length;
      if (start3 < 0) {
        start3 = -start3 > length ? 0 : length + start3;
      }
      end = end > length ? length : end;
      if (end < 0) {
        end += length;
      }
      length = start3 > end ? 0 : end - start3 >>> 0;
      start3 >>>= 0;
      var result = Array(length);
      while (++index2 < length) {
        result[index2] = array[index2 + start3];
      }
      return result;
    }
    module2.exports = baseSlice;
  }
});

// node_modules/lodash/_castSlice.js
var require_castSlice = __commonJS({
  "node_modules/lodash/_castSlice.js"(exports, module2) {
    var baseSlice = require_baseSlice();
    function castSlice(array, start3, end) {
      var length = array.length;
      end = end === void 0 ? length : end;
      return !start3 && end >= length ? array : baseSlice(array, start3, end);
    }
    module2.exports = castSlice;
  }
});

// node_modules/lodash/_hasUnicode.js
var require_hasUnicode = __commonJS({
  "node_modules/lodash/_hasUnicode.js"(exports, module2) {
    var rsAstralRange = "\\ud800-\\udfff";
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsVarRange = "\\ufe0e\\ufe0f";
    var rsZWJ = "\\u200d";
    var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
    function hasUnicode(string3) {
      return reHasUnicode.test(string3);
    }
    module2.exports = hasUnicode;
  }
});

// node_modules/lodash/_asciiToArray.js
var require_asciiToArray = __commonJS({
  "node_modules/lodash/_asciiToArray.js"(exports, module2) {
    function asciiToArray(string3) {
      return string3.split("");
    }
    module2.exports = asciiToArray;
  }
});

// node_modules/lodash/_unicodeToArray.js
var require_unicodeToArray = __commonJS({
  "node_modules/lodash/_unicodeToArray.js"(exports, module2) {
    var rsAstralRange = "\\ud800-\\udfff";
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsVarRange = "\\ufe0e\\ufe0f";
    var rsAstral = "[" + rsAstralRange + "]";
    var rsCombo = "[" + rsComboRange + "]";
    var rsFitz = "\\ud83c[\\udffb-\\udfff]";
    var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
    var rsNonAstral = "[^" + rsAstralRange + "]";
    var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
    var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
    var rsZWJ = "\\u200d";
    var reOptMod = rsModifier + "?";
    var rsOptVar = "[" + rsVarRange + "]?";
    var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
    var rsSeq = rsOptVar + reOptMod + rsOptJoin;
    var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
    var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
    function unicodeToArray(string3) {
      return string3.match(reUnicode) || [];
    }
    module2.exports = unicodeToArray;
  }
});

// node_modules/lodash/_stringToArray.js
var require_stringToArray = __commonJS({
  "node_modules/lodash/_stringToArray.js"(exports, module2) {
    var asciiToArray = require_asciiToArray();
    var hasUnicode = require_hasUnicode();
    var unicodeToArray = require_unicodeToArray();
    function stringToArray(string3) {
      return hasUnicode(string3) ? unicodeToArray(string3) : asciiToArray(string3);
    }
    module2.exports = stringToArray;
  }
});

// node_modules/lodash/_createCaseFirst.js
var require_createCaseFirst = __commonJS({
  "node_modules/lodash/_createCaseFirst.js"(exports, module2) {
    var castSlice = require_castSlice();
    var hasUnicode = require_hasUnicode();
    var stringToArray = require_stringToArray();
    var toString4 = require_toString();
    function createCaseFirst(methodName) {
      return function(string3) {
        string3 = toString4(string3);
        var strSymbols = hasUnicode(string3) ? stringToArray(string3) : void 0;
        var chr = strSymbols ? strSymbols[0] : string3.charAt(0);
        var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string3.slice(1);
        return chr[methodName]() + trailing;
      };
    }
    module2.exports = createCaseFirst;
  }
});

// node_modules/lodash/upperFirst.js
var require_upperFirst = __commonJS({
  "node_modules/lodash/upperFirst.js"(exports, module2) {
    var createCaseFirst = require_createCaseFirst();
    var upperFirst = createCaseFirst("toUpperCase");
    module2.exports = upperFirst;
  }
});

// node_modules/lodash/capitalize.js
var require_capitalize = __commonJS({
  "node_modules/lodash/capitalize.js"(exports, module2) {
    var toString4 = require_toString();
    var upperFirst = require_upperFirst();
    function capitalize(string3) {
      return upperFirst(toString4(string3).toLowerCase());
    }
    module2.exports = capitalize;
  }
});

// node_modules/lodash/_arrayReduce.js
var require_arrayReduce = __commonJS({
  "node_modules/lodash/_arrayReduce.js"(exports, module2) {
    function arrayReduce(array, iteratee, accumulator, initAccum) {
      var index2 = -1, length = array == null ? 0 : array.length;
      if (initAccum && length) {
        accumulator = array[++index2];
      }
      while (++index2 < length) {
        accumulator = iteratee(accumulator, array[index2], index2, array);
      }
      return accumulator;
    }
    module2.exports = arrayReduce;
  }
});

// node_modules/lodash/_basePropertyOf.js
var require_basePropertyOf = __commonJS({
  "node_modules/lodash/_basePropertyOf.js"(exports, module2) {
    function basePropertyOf(object) {
      return function(key2) {
        return object == null ? void 0 : object[key2];
      };
    }
    module2.exports = basePropertyOf;
  }
});

// node_modules/lodash/_deburrLetter.js
var require_deburrLetter = __commonJS({
  "node_modules/lodash/_deburrLetter.js"(exports, module2) {
    var basePropertyOf = require_basePropertyOf();
    var deburredLetters = {
      // Latin-1 Supplement block.
      "\xC0": "A",
      "\xC1": "A",
      "\xC2": "A",
      "\xC3": "A",
      "\xC4": "A",
      "\xC5": "A",
      "\xE0": "a",
      "\xE1": "a",
      "\xE2": "a",
      "\xE3": "a",
      "\xE4": "a",
      "\xE5": "a",
      "\xC7": "C",
      "\xE7": "c",
      "\xD0": "D",
      "\xF0": "d",
      "\xC8": "E",
      "\xC9": "E",
      "\xCA": "E",
      "\xCB": "E",
      "\xE8": "e",
      "\xE9": "e",
      "\xEA": "e",
      "\xEB": "e",
      "\xCC": "I",
      "\xCD": "I",
      "\xCE": "I",
      "\xCF": "I",
      "\xEC": "i",
      "\xED": "i",
      "\xEE": "i",
      "\xEF": "i",
      "\xD1": "N",
      "\xF1": "n",
      "\xD2": "O",
      "\xD3": "O",
      "\xD4": "O",
      "\xD5": "O",
      "\xD6": "O",
      "\xD8": "O",
      "\xF2": "o",
      "\xF3": "o",
      "\xF4": "o",
      "\xF5": "o",
      "\xF6": "o",
      "\xF8": "o",
      "\xD9": "U",
      "\xDA": "U",
      "\xDB": "U",
      "\xDC": "U",
      "\xF9": "u",
      "\xFA": "u",
      "\xFB": "u",
      "\xFC": "u",
      "\xDD": "Y",
      "\xFD": "y",
      "\xFF": "y",
      "\xC6": "Ae",
      "\xE6": "ae",
      "\xDE": "Th",
      "\xFE": "th",
      "\xDF": "ss",
      // Latin Extended-A block.
      "\u0100": "A",
      "\u0102": "A",
      "\u0104": "A",
      "\u0101": "a",
      "\u0103": "a",
      "\u0105": "a",
      "\u0106": "C",
      "\u0108": "C",
      "\u010A": "C",
      "\u010C": "C",
      "\u0107": "c",
      "\u0109": "c",
      "\u010B": "c",
      "\u010D": "c",
      "\u010E": "D",
      "\u0110": "D",
      "\u010F": "d",
      "\u0111": "d",
      "\u0112": "E",
      "\u0114": "E",
      "\u0116": "E",
      "\u0118": "E",
      "\u011A": "E",
      "\u0113": "e",
      "\u0115": "e",
      "\u0117": "e",
      "\u0119": "e",
      "\u011B": "e",
      "\u011C": "G",
      "\u011E": "G",
      "\u0120": "G",
      "\u0122": "G",
      "\u011D": "g",
      "\u011F": "g",
      "\u0121": "g",
      "\u0123": "g",
      "\u0124": "H",
      "\u0126": "H",
      "\u0125": "h",
      "\u0127": "h",
      "\u0128": "I",
      "\u012A": "I",
      "\u012C": "I",
      "\u012E": "I",
      "\u0130": "I",
      "\u0129": "i",
      "\u012B": "i",
      "\u012D": "i",
      "\u012F": "i",
      "\u0131": "i",
      "\u0134": "J",
      "\u0135": "j",
      "\u0136": "K",
      "\u0137": "k",
      "\u0138": "k",
      "\u0139": "L",
      "\u013B": "L",
      "\u013D": "L",
      "\u013F": "L",
      "\u0141": "L",
      "\u013A": "l",
      "\u013C": "l",
      "\u013E": "l",
      "\u0140": "l",
      "\u0142": "l",
      "\u0143": "N",
      "\u0145": "N",
      "\u0147": "N",
      "\u014A": "N",
      "\u0144": "n",
      "\u0146": "n",
      "\u0148": "n",
      "\u014B": "n",
      "\u014C": "O",
      "\u014E": "O",
      "\u0150": "O",
      "\u014D": "o",
      "\u014F": "o",
      "\u0151": "o",
      "\u0154": "R",
      "\u0156": "R",
      "\u0158": "R",
      "\u0155": "r",
      "\u0157": "r",
      "\u0159": "r",
      "\u015A": "S",
      "\u015C": "S",
      "\u015E": "S",
      "\u0160": "S",
      "\u015B": "s",
      "\u015D": "s",
      "\u015F": "s",
      "\u0161": "s",
      "\u0162": "T",
      "\u0164": "T",
      "\u0166": "T",
      "\u0163": "t",
      "\u0165": "t",
      "\u0167": "t",
      "\u0168": "U",
      "\u016A": "U",
      "\u016C": "U",
      "\u016E": "U",
      "\u0170": "U",
      "\u0172": "U",
      "\u0169": "u",
      "\u016B": "u",
      "\u016D": "u",
      "\u016F": "u",
      "\u0171": "u",
      "\u0173": "u",
      "\u0174": "W",
      "\u0175": "w",
      "\u0176": "Y",
      "\u0177": "y",
      "\u0178": "Y",
      "\u0179": "Z",
      "\u017B": "Z",
      "\u017D": "Z",
      "\u017A": "z",
      "\u017C": "z",
      "\u017E": "z",
      "\u0132": "IJ",
      "\u0133": "ij",
      "\u0152": "Oe",
      "\u0153": "oe",
      "\u0149": "'n",
      "\u017F": "s"
    };
    var deburrLetter = basePropertyOf(deburredLetters);
    module2.exports = deburrLetter;
  }
});

// node_modules/lodash/deburr.js
var require_deburr = __commonJS({
  "node_modules/lodash/deburr.js"(exports, module2) {
    var deburrLetter = require_deburrLetter();
    var toString4 = require_toString();
    var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsCombo = "[" + rsComboRange + "]";
    var reComboMark = RegExp(rsCombo, "g");
    function deburr(string3) {
      string3 = toString4(string3);
      return string3 && string3.replace(reLatin, deburrLetter).replace(reComboMark, "");
    }
    module2.exports = deburr;
  }
});

// node_modules/lodash/_asciiWords.js
var require_asciiWords = __commonJS({
  "node_modules/lodash/_asciiWords.js"(exports, module2) {
    var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
    function asciiWords(string3) {
      return string3.match(reAsciiWord) || [];
    }
    module2.exports = asciiWords;
  }
});

// node_modules/lodash/_hasUnicodeWord.js
var require_hasUnicodeWord = __commonJS({
  "node_modules/lodash/_hasUnicodeWord.js"(exports, module2) {
    var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
    function hasUnicodeWord(string3) {
      return reHasUnicodeWord.test(string3);
    }
    module2.exports = hasUnicodeWord;
  }
});

// node_modules/lodash/_unicodeWords.js
var require_unicodeWords = __commonJS({
  "node_modules/lodash/_unicodeWords.js"(exports, module2) {
    var rsAstralRange = "\\ud800-\\udfff";
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsDingbatRange = "\\u2700-\\u27bf";
    var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
    var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
    var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
    var rsPunctuationRange = "\\u2000-\\u206f";
    var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
    var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
    var rsVarRange = "\\ufe0e\\ufe0f";
    var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
    var rsApos = "['\u2019]";
    var rsBreak = "[" + rsBreakRange + "]";
    var rsCombo = "[" + rsComboRange + "]";
    var rsDigits = "\\d+";
    var rsDingbat = "[" + rsDingbatRange + "]";
    var rsLower = "[" + rsLowerRange + "]";
    var rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
    var rsFitz = "\\ud83c[\\udffb-\\udfff]";
    var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
    var rsNonAstral = "[^" + rsAstralRange + "]";
    var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
    var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
    var rsUpper = "[" + rsUpperRange + "]";
    var rsZWJ = "\\u200d";
    var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")";
    var rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")";
    var rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?";
    var rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?";
    var reOptMod = rsModifier + "?";
    var rsOptVar = "[" + rsVarRange + "]?";
    var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
    var rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])";
    var rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])";
    var rsSeq = rsOptVar + reOptMod + rsOptJoin;
    var rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
    var reUnicodeWord = RegExp([
      rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
      rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
      rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
      rsUpper + "+" + rsOptContrUpper,
      rsOrdUpper,
      rsOrdLower,
      rsDigits,
      rsEmoji
    ].join("|"), "g");
    function unicodeWords(string3) {
      return string3.match(reUnicodeWord) || [];
    }
    module2.exports = unicodeWords;
  }
});

// node_modules/lodash/words.js
var require_words = __commonJS({
  "node_modules/lodash/words.js"(exports, module2) {
    var asciiWords = require_asciiWords();
    var hasUnicodeWord = require_hasUnicodeWord();
    var toString4 = require_toString();
    var unicodeWords = require_unicodeWords();
    function words(string3, pattern, guard) {
      string3 = toString4(string3);
      pattern = guard ? void 0 : pattern;
      if (pattern === void 0) {
        return hasUnicodeWord(string3) ? unicodeWords(string3) : asciiWords(string3);
      }
      return string3.match(pattern) || [];
    }
    module2.exports = words;
  }
});

// node_modules/lodash/_createCompounder.js
var require_createCompounder = __commonJS({
  "node_modules/lodash/_createCompounder.js"(exports, module2) {
    var arrayReduce = require_arrayReduce();
    var deburr = require_deburr();
    var words = require_words();
    var rsApos = "['\u2019]";
    var reApos = RegExp(rsApos, "g");
    function createCompounder(callback) {
      return function(string3) {
        return arrayReduce(words(deburr(string3).replace(reApos, "")), callback, "");
      };
    }
    module2.exports = createCompounder;
  }
});

// node_modules/lodash/camelCase.js
var require_camelCase = __commonJS({
  "node_modules/lodash/camelCase.js"(exports, module2) {
    var capitalize = require_capitalize();
    var createCompounder = require_createCompounder();
    var camelCase2 = createCompounder(function(result, word, index2) {
      word = word.toLowerCase();
      return result + (index2 ? capitalize(word) : word);
    });
    module2.exports = camelCase2;
  }
});

// node_modules/js-string-escape/index.js
var require_js_string_escape = __commonJS({
  "node_modules/js-string-escape/index.js"(exports, module2) {
    module2.exports = function(string3) {
      return ("" + string3).replace(/["'\\\n\r\u2028\u2029]/g, function(character) {
        switch (character) {
          case '"':
          case "'":
          case "\\":
            return "\\" + character;
          case "\n":
            return "\\n";
          case "\r":
            return "\\r";
          case "\u2028":
            return "\\u2028";
          case "\u2029":
            return "\\u2029";
        }
      });
    };
  }
});

// node_modules/@babel/helpers/lib/helpers-generated.js
var require_helpers_generated = __commonJS({
  "node_modules/@babel/helpers/lib/helpers-generated.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _template = require_lib11();
    function helper(minVersion, source2) {
      return Object.freeze({
        minVersion,
        ast: () => _template.default.program.ast(source2, {
          preserveComments: true
        })
      });
    }
    var _default = Object.freeze({
      AsyncGenerator: helper("7.0.0-beta.0", 'import OverloadYield from"OverloadYield";export default function AsyncGenerator(gen){var front,back;function resume(key,arg){try{var result=gen[key](arg),value=result.value,overloaded=value instanceof OverloadYield;Promise.resolve(overloaded?value.v:value).then((function(arg){if(overloaded){var nextKey="return"===key?"return":"next";if(!value.k||arg.done)return resume(nextKey,arg);arg=gen[nextKey](arg).value}settle(result.done?"return":"normal",arg)}),(function(err){resume("throw",err)}))}catch(err){settle("throw",err)}}function settle(type,value){switch(type){case"return":front.resolve({value:value,done:!0});break;case"throw":front.reject(value);break;default:front.resolve({value:value,done:!1})}(front=front.next)?resume(front.key,front.arg):back=null}this._invoke=function(key,arg){return new Promise((function(resolve,reject){var request={key:key,arg:arg,resolve:resolve,reject:reject,next:null};back?back=back.next=request:(front=back=request,resume(key,arg))}))},"function"!=typeof gen.return&&(this.return=void 0)}AsyncGenerator.prototype["function"==typeof Symbol&&Symbol.asyncIterator||"@@asyncIterator"]=function(){return this},AsyncGenerator.prototype.next=function(arg){return this._invoke("next",arg)},AsyncGenerator.prototype.throw=function(arg){return this._invoke("throw",arg)},AsyncGenerator.prototype.return=function(arg){return this._invoke("return",arg)};'),
      OverloadYield: helper("7.18.14", "export default function _OverloadYield(value,kind){this.v=value,this.k=kind}"),
      applyDecs: helper("7.17.8", 'function old_createMetadataMethodsForProperty(metadataMap,kind,property,decoratorFinishedRef){return{getMetadata:function(key){old_assertNotFinished(decoratorFinishedRef,"getMetadata"),old_assertMetadataKey(key);var metadataForKey=metadataMap[key];if(void 0!==metadataForKey)if(1===kind){var pub=metadataForKey.public;if(void 0!==pub)return pub[property]}else if(2===kind){var priv=metadataForKey.private;if(void 0!==priv)return priv.get(property)}else if(Object.hasOwnProperty.call(metadataForKey,"constructor"))return metadataForKey.constructor},setMetadata:function(key,value){old_assertNotFinished(decoratorFinishedRef,"setMetadata"),old_assertMetadataKey(key);var metadataForKey=metadataMap[key];if(void 0===metadataForKey&&(metadataForKey=metadataMap[key]={}),1===kind){var pub=metadataForKey.public;void 0===pub&&(pub=metadataForKey.public={}),pub[property]=value}else if(2===kind){var priv=metadataForKey.priv;void 0===priv&&(priv=metadataForKey.private=new Map),priv.set(property,value)}else metadataForKey.constructor=value}}}function old_convertMetadataMapToFinal(obj,metadataMap){var parentMetadataMap=obj[Symbol.metadata||Symbol.for("Symbol.metadata")],metadataKeys=Object.getOwnPropertySymbols(metadataMap);if(0!==metadataKeys.length){for(var i=0;i<metadataKeys.length;i++){var key=metadataKeys[i],metaForKey=metadataMap[key],parentMetaForKey=parentMetadataMap?parentMetadataMap[key]:null,pub=metaForKey.public,parentPub=parentMetaForKey?parentMetaForKey.public:null;pub&&parentPub&&Object.setPrototypeOf(pub,parentPub);var priv=metaForKey.private;if(priv){var privArr=Array.from(priv.values()),parentPriv=parentMetaForKey?parentMetaForKey.private:null;parentPriv&&(privArr=privArr.concat(parentPriv)),metaForKey.private=privArr}parentMetaForKey&&Object.setPrototypeOf(metaForKey,parentMetaForKey)}parentMetadataMap&&Object.setPrototypeOf(metadataMap,parentMetadataMap),obj[Symbol.metadata||Symbol.for("Symbol.metadata")]=metadataMap}}function old_createAddInitializerMethod(initializers,decoratorFinishedRef){return function(initializer){old_assertNotFinished(decoratorFinishedRef,"addInitializer"),old_assertCallable(initializer,"An initializer"),initializers.push(initializer)}}function old_memberDec(dec,name,desc,metadataMap,initializers,kind,isStatic,isPrivate,value){var kindStr;switch(kind){case 1:kindStr="accessor";break;case 2:kindStr="method";break;case 3:kindStr="getter";break;case 4:kindStr="setter";break;default:kindStr="field"}var metadataKind,metadataName,ctx={kind:kindStr,name:isPrivate?"#"+name:name,isStatic:isStatic,isPrivate:isPrivate},decoratorFinishedRef={v:!1};if(0!==kind&&(ctx.addInitializer=old_createAddInitializerMethod(initializers,decoratorFinishedRef)),isPrivate){metadataKind=2,metadataName=Symbol(name);var access={};0===kind?(access.get=desc.get,access.set=desc.set):2===kind?access.get=function(){return desc.value}:(1!==kind&&3!==kind||(access.get=function(){return desc.get.call(this)}),1!==kind&&4!==kind||(access.set=function(v){desc.set.call(this,v)})),ctx.access=access}else metadataKind=1,metadataName=name;try{return dec(value,Object.assign(ctx,old_createMetadataMethodsForProperty(metadataMap,metadataKind,metadataName,decoratorFinishedRef)))}finally{decoratorFinishedRef.v=!0}}function old_assertNotFinished(decoratorFinishedRef,fnName){if(decoratorFinishedRef.v)throw new Error("attempted to call "+fnName+" after decoration was finished")}function old_assertMetadataKey(key){if("symbol"!=typeof key)throw new TypeError("Metadata keys must be symbols, received: "+key)}function old_assertCallable(fn,hint){if("function"!=typeof fn)throw new TypeError(hint+" must be a function")}function old_assertValidReturnValue(kind,value){var type=typeof value;if(1===kind){if("object"!==type||null===value)throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");void 0!==value.get&&old_assertCallable(value.get,"accessor.get"),void 0!==value.set&&old_assertCallable(value.set,"accessor.set"),void 0!==value.init&&old_assertCallable(value.init,"accessor.init"),void 0!==value.initializer&&old_assertCallable(value.initializer,"accessor.initializer")}else if("function"!==type){var hint;throw hint=0===kind?"field":10===kind?"class":"method",new TypeError(hint+" decorators must return a function or void 0")}}function old_getInit(desc){var initializer;return null==(initializer=desc.init)&&(initializer=desc.initializer)&&"undefined"!=typeof console&&console.warn(".initializer has been renamed to .init as of March 2022"),initializer}function old_applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,metadataMap,initializers){var desc,initializer,value,newValue,get,set,decs=decInfo[0];if(isPrivate?desc=0===kind||1===kind?{get:decInfo[3],set:decInfo[4]}:3===kind?{get:decInfo[3]}:4===kind?{set:decInfo[3]}:{value:decInfo[3]}:0!==kind&&(desc=Object.getOwnPropertyDescriptor(base,name)),1===kind?value={get:desc.get,set:desc.set}:2===kind?value=desc.value:3===kind?value=desc.get:4===kind&&(value=desc.set),"function"==typeof decs)void 0!==(newValue=old_memberDec(decs,name,desc,metadataMap,initializers,kind,isStatic,isPrivate,value))&&(old_assertValidReturnValue(kind,newValue),0===kind?initializer=newValue:1===kind?(initializer=old_getInit(newValue),get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue);else for(var i=decs.length-1;i>=0;i--){var newInit;if(void 0!==(newValue=old_memberDec(decs[i],name,desc,metadataMap,initializers,kind,isStatic,isPrivate,value)))old_assertValidReturnValue(kind,newValue),0===kind?newInit=newValue:1===kind?(newInit=old_getInit(newValue),get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue,void 0!==newInit&&(void 0===initializer?initializer=newInit:"function"==typeof initializer?initializer=[initializer,newInit]:initializer.push(newInit))}if(0===kind||1===kind){if(void 0===initializer)initializer=function(instance,init){return init};else if("function"!=typeof initializer){var ownInitializers=initializer;initializer=function(instance,init){for(var value=init,i=0;i<ownInitializers.length;i++)value=ownInitializers[i].call(instance,value);return value}}else{var originalInitializer=initializer;initializer=function(instance,init){return originalInitializer.call(instance,init)}}ret.push(initializer)}0!==kind&&(1===kind?(desc.get=value.get,desc.set=value.set):2===kind?desc.value=value:3===kind?desc.get=value:4===kind&&(desc.set=value),isPrivate?1===kind?(ret.push((function(instance,args){return value.get.call(instance,args)})),ret.push((function(instance,args){return value.set.call(instance,args)}))):2===kind?ret.push(value):ret.push((function(instance,args){return value.call(instance,args)})):Object.defineProperty(base,name,desc))}function old_applyMemberDecs(ret,Class,protoMetadataMap,staticMetadataMap,decInfos){for(var protoInitializers,staticInitializers,existingProtoNonFields=new Map,existingStaticNonFields=new Map,i=0;i<decInfos.length;i++){var decInfo=decInfos[i];if(Array.isArray(decInfo)){var base,metadataMap,initializers,kind=decInfo[1],name=decInfo[2],isPrivate=decInfo.length>3,isStatic=kind>=5;if(isStatic?(base=Class,metadataMap=staticMetadataMap,0!==(kind-=5)&&(initializers=staticInitializers=staticInitializers||[])):(base=Class.prototype,metadataMap=protoMetadataMap,0!==kind&&(initializers=protoInitializers=protoInitializers||[])),0!==kind&&!isPrivate){var existingNonFields=isStatic?existingStaticNonFields:existingProtoNonFields,existingKind=existingNonFields.get(name)||0;if(!0===existingKind||3===existingKind&&4!==kind||4===existingKind&&3!==kind)throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+name);!existingKind&&kind>2?existingNonFields.set(name,kind):existingNonFields.set(name,!0)}old_applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,metadataMap,initializers)}}old_pushInitializers(ret,protoInitializers),old_pushInitializers(ret,staticInitializers)}function old_pushInitializers(ret,initializers){initializers&&ret.push((function(instance){for(var i=0;i<initializers.length;i++)initializers[i].call(instance);return instance}))}function old_applyClassDecs(ret,targetClass,metadataMap,classDecs){if(classDecs.length>0){for(var initializers=[],newClass=targetClass,name=targetClass.name,i=classDecs.length-1;i>=0;i--){var decoratorFinishedRef={v:!1};try{var ctx=Object.assign({kind:"class",name:name,addInitializer:old_createAddInitializerMethod(initializers,decoratorFinishedRef)},old_createMetadataMethodsForProperty(metadataMap,0,name,decoratorFinishedRef)),nextNewClass=classDecs[i](newClass,ctx)}finally{decoratorFinishedRef.v=!0}void 0!==nextNewClass&&(old_assertValidReturnValue(10,nextNewClass),newClass=nextNewClass)}ret.push(newClass,(function(){for(var i=0;i<initializers.length;i++)initializers[i].call(newClass)}))}}export default function applyDecs(targetClass,memberDecs,classDecs){var ret=[],staticMetadataMap={},protoMetadataMap={};return old_applyMemberDecs(ret,targetClass,protoMetadataMap,staticMetadataMap,memberDecs),old_convertMetadataMapToFinal(targetClass.prototype,protoMetadataMap),old_applyClassDecs(ret,targetClass,staticMetadataMap,classDecs),old_convertMetadataMapToFinal(targetClass,staticMetadataMap),ret}'),
      applyDecs2203: helper("7.19.0", 'function applyDecs2203Factory(){function createAddInitializerMethod(initializers,decoratorFinishedRef){return function(initializer){!function(decoratorFinishedRef,fnName){if(decoratorFinishedRef.v)throw new Error("attempted to call "+fnName+" after decoration was finished")}(decoratorFinishedRef,"addInitializer"),assertCallable(initializer,"An initializer"),initializers.push(initializer)}}function memberDec(dec,name,desc,initializers,kind,isStatic,isPrivate,value){var kindStr;switch(kind){case 1:kindStr="accessor";break;case 2:kindStr="method";break;case 3:kindStr="getter";break;case 4:kindStr="setter";break;default:kindStr="field"}var get,set,ctx={kind:kindStr,name:isPrivate?"#"+name:name,static:isStatic,private:isPrivate},decoratorFinishedRef={v:!1};0!==kind&&(ctx.addInitializer=createAddInitializerMethod(initializers,decoratorFinishedRef)),0===kind?isPrivate?(get=desc.get,set=desc.set):(get=function(){return this[name]},set=function(v){this[name]=v}):2===kind?get=function(){return desc.value}:(1!==kind&&3!==kind||(get=function(){return desc.get.call(this)}),1!==kind&&4!==kind||(set=function(v){desc.set.call(this,v)})),ctx.access=get&&set?{get:get,set:set}:get?{get:get}:{set:set};try{return dec(value,ctx)}finally{decoratorFinishedRef.v=!0}}function assertCallable(fn,hint){if("function"!=typeof fn)throw new TypeError(hint+" must be a function")}function assertValidReturnValue(kind,value){var type=typeof value;if(1===kind){if("object"!==type||null===value)throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");void 0!==value.get&&assertCallable(value.get,"accessor.get"),void 0!==value.set&&assertCallable(value.set,"accessor.set"),void 0!==value.init&&assertCallable(value.init,"accessor.init")}else if("function"!==type){var hint;throw hint=0===kind?"field":10===kind?"class":"method",new TypeError(hint+" decorators must return a function or void 0")}}function applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,initializers){var desc,init,value,newValue,get,set,decs=decInfo[0];if(isPrivate?desc=0===kind||1===kind?{get:decInfo[3],set:decInfo[4]}:3===kind?{get:decInfo[3]}:4===kind?{set:decInfo[3]}:{value:decInfo[3]}:0!==kind&&(desc=Object.getOwnPropertyDescriptor(base,name)),1===kind?value={get:desc.get,set:desc.set}:2===kind?value=desc.value:3===kind?value=desc.get:4===kind&&(value=desc.set),"function"==typeof decs)void 0!==(newValue=memberDec(decs,name,desc,initializers,kind,isStatic,isPrivate,value))&&(assertValidReturnValue(kind,newValue),0===kind?init=newValue:1===kind?(init=newValue.init,get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue);else for(var i=decs.length-1;i>=0;i--){var newInit;if(void 0!==(newValue=memberDec(decs[i],name,desc,initializers,kind,isStatic,isPrivate,value)))assertValidReturnValue(kind,newValue),0===kind?newInit=newValue:1===kind?(newInit=newValue.init,get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue,void 0!==newInit&&(void 0===init?init=newInit:"function"==typeof init?init=[init,newInit]:init.push(newInit))}if(0===kind||1===kind){if(void 0===init)init=function(instance,init){return init};else if("function"!=typeof init){var ownInitializers=init;init=function(instance,init){for(var value=init,i=0;i<ownInitializers.length;i++)value=ownInitializers[i].call(instance,value);return value}}else{var originalInitializer=init;init=function(instance,init){return originalInitializer.call(instance,init)}}ret.push(init)}0!==kind&&(1===kind?(desc.get=value.get,desc.set=value.set):2===kind?desc.value=value:3===kind?desc.get=value:4===kind&&(desc.set=value),isPrivate?1===kind?(ret.push((function(instance,args){return value.get.call(instance,args)})),ret.push((function(instance,args){return value.set.call(instance,args)}))):2===kind?ret.push(value):ret.push((function(instance,args){return value.call(instance,args)})):Object.defineProperty(base,name,desc))}function pushInitializers(ret,initializers){initializers&&ret.push((function(instance){for(var i=0;i<initializers.length;i++)initializers[i].call(instance);return instance}))}return function(targetClass,memberDecs,classDecs){var ret=[];return function(ret,Class,decInfos){for(var protoInitializers,staticInitializers,existingProtoNonFields=new Map,existingStaticNonFields=new Map,i=0;i<decInfos.length;i++){var decInfo=decInfos[i];if(Array.isArray(decInfo)){var base,initializers,kind=decInfo[1],name=decInfo[2],isPrivate=decInfo.length>3,isStatic=kind>=5;if(isStatic?(base=Class,0!=(kind-=5)&&(initializers=staticInitializers=staticInitializers||[])):(base=Class.prototype,0!==kind&&(initializers=protoInitializers=protoInitializers||[])),0!==kind&&!isPrivate){var existingNonFields=isStatic?existingStaticNonFields:existingProtoNonFields,existingKind=existingNonFields.get(name)||0;if(!0===existingKind||3===existingKind&&4!==kind||4===existingKind&&3!==kind)throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+name);!existingKind&&kind>2?existingNonFields.set(name,kind):existingNonFields.set(name,!0)}applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,initializers)}}pushInitializers(ret,protoInitializers),pushInitializers(ret,staticInitializers)}(ret,targetClass,memberDecs),function(ret,targetClass,classDecs){if(classDecs.length>0){for(var initializers=[],newClass=targetClass,name=targetClass.name,i=classDecs.length-1;i>=0;i--){var decoratorFinishedRef={v:!1};try{var nextNewClass=classDecs[i](newClass,{kind:"class",name:name,addInitializer:createAddInitializerMethod(initializers,decoratorFinishedRef)})}finally{decoratorFinishedRef.v=!0}void 0!==nextNewClass&&(assertValidReturnValue(10,nextNewClass),newClass=nextNewClass)}ret.push(newClass,(function(){for(var i=0;i<initializers.length;i++)initializers[i].call(newClass)}))}}(ret,targetClass,classDecs),ret}}var applyDecs2203Impl;export default function applyDecs2203(targetClass,memberDecs,classDecs){return(applyDecs2203Impl=applyDecs2203Impl||applyDecs2203Factory())(targetClass,memberDecs,classDecs)}'),
      applyDecs2203R: helper("7.20.0", 'function applyDecs2203RFactory(){function createAddInitializerMethod(initializers,decoratorFinishedRef){return function(initializer){!function(decoratorFinishedRef,fnName){if(decoratorFinishedRef.v)throw new Error("attempted to call "+fnName+" after decoration was finished")}(decoratorFinishedRef,"addInitializer"),assertCallable(initializer,"An initializer"),initializers.push(initializer)}}function memberDec(dec,name,desc,initializers,kind,isStatic,isPrivate,value){var kindStr;switch(kind){case 1:kindStr="accessor";break;case 2:kindStr="method";break;case 3:kindStr="getter";break;case 4:kindStr="setter";break;default:kindStr="field"}var get,set,ctx={kind:kindStr,name:isPrivate?"#"+name:name,static:isStatic,private:isPrivate},decoratorFinishedRef={v:!1};0!==kind&&(ctx.addInitializer=createAddInitializerMethod(initializers,decoratorFinishedRef)),0===kind?isPrivate?(get=desc.get,set=desc.set):(get=function(){return this[name]},set=function(v){this[name]=v}):2===kind?get=function(){return desc.value}:(1!==kind&&3!==kind||(get=function(){return desc.get.call(this)}),1!==kind&&4!==kind||(set=function(v){desc.set.call(this,v)})),ctx.access=get&&set?{get:get,set:set}:get?{get:get}:{set:set};try{return dec(value,ctx)}finally{decoratorFinishedRef.v=!0}}function assertCallable(fn,hint){if("function"!=typeof fn)throw new TypeError(hint+" must be a function")}function assertValidReturnValue(kind,value){var type=typeof value;if(1===kind){if("object"!==type||null===value)throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");void 0!==value.get&&assertCallable(value.get,"accessor.get"),void 0!==value.set&&assertCallable(value.set,"accessor.set"),void 0!==value.init&&assertCallable(value.init,"accessor.init")}else if("function"!==type){var hint;throw hint=0===kind?"field":10===kind?"class":"method",new TypeError(hint+" decorators must return a function or void 0")}}function applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,initializers){var desc,init,value,newValue,get,set,decs=decInfo[0];if(isPrivate?desc=0===kind||1===kind?{get:decInfo[3],set:decInfo[4]}:3===kind?{get:decInfo[3]}:4===kind?{set:decInfo[3]}:{value:decInfo[3]}:0!==kind&&(desc=Object.getOwnPropertyDescriptor(base,name)),1===kind?value={get:desc.get,set:desc.set}:2===kind?value=desc.value:3===kind?value=desc.get:4===kind&&(value=desc.set),"function"==typeof decs)void 0!==(newValue=memberDec(decs,name,desc,initializers,kind,isStatic,isPrivate,value))&&(assertValidReturnValue(kind,newValue),0===kind?init=newValue:1===kind?(init=newValue.init,get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue);else for(var i=decs.length-1;i>=0;i--){var newInit;if(void 0!==(newValue=memberDec(decs[i],name,desc,initializers,kind,isStatic,isPrivate,value)))assertValidReturnValue(kind,newValue),0===kind?newInit=newValue:1===kind?(newInit=newValue.init,get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue,void 0!==newInit&&(void 0===init?init=newInit:"function"==typeof init?init=[init,newInit]:init.push(newInit))}if(0===kind||1===kind){if(void 0===init)init=function(instance,init){return init};else if("function"!=typeof init){var ownInitializers=init;init=function(instance,init){for(var value=init,i=0;i<ownInitializers.length;i++)value=ownInitializers[i].call(instance,value);return value}}else{var originalInitializer=init;init=function(instance,init){return originalInitializer.call(instance,init)}}ret.push(init)}0!==kind&&(1===kind?(desc.get=value.get,desc.set=value.set):2===kind?desc.value=value:3===kind?desc.get=value:4===kind&&(desc.set=value),isPrivate?1===kind?(ret.push((function(instance,args){return value.get.call(instance,args)})),ret.push((function(instance,args){return value.set.call(instance,args)}))):2===kind?ret.push(value):ret.push((function(instance,args){return value.call(instance,args)})):Object.defineProperty(base,name,desc))}function applyMemberDecs(Class,decInfos){for(var protoInitializers,staticInitializers,ret=[],existingProtoNonFields=new Map,existingStaticNonFields=new Map,i=0;i<decInfos.length;i++){var decInfo=decInfos[i];if(Array.isArray(decInfo)){var base,initializers,kind=decInfo[1],name=decInfo[2],isPrivate=decInfo.length>3,isStatic=kind>=5;if(isStatic?(base=Class,0!==(kind-=5)&&(initializers=staticInitializers=staticInitializers||[])):(base=Class.prototype,0!==kind&&(initializers=protoInitializers=protoInitializers||[])),0!==kind&&!isPrivate){var existingNonFields=isStatic?existingStaticNonFields:existingProtoNonFields,existingKind=existingNonFields.get(name)||0;if(!0===existingKind||3===existingKind&&4!==kind||4===existingKind&&3!==kind)throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+name);!existingKind&&kind>2?existingNonFields.set(name,kind):existingNonFields.set(name,!0)}applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,initializers)}}return pushInitializers(ret,protoInitializers),pushInitializers(ret,staticInitializers),ret}function pushInitializers(ret,initializers){initializers&&ret.push((function(instance){for(var i=0;i<initializers.length;i++)initializers[i].call(instance);return instance}))}return function(targetClass,memberDecs,classDecs){return{e:applyMemberDecs(targetClass,memberDecs),get c(){return function(targetClass,classDecs){if(classDecs.length>0){for(var initializers=[],newClass=targetClass,name=targetClass.name,i=classDecs.length-1;i>=0;i--){var decoratorFinishedRef={v:!1};try{var nextNewClass=classDecs[i](newClass,{kind:"class",name:name,addInitializer:createAddInitializerMethod(initializers,decoratorFinishedRef)})}finally{decoratorFinishedRef.v=!0}void 0!==nextNewClass&&(assertValidReturnValue(10,nextNewClass),newClass=nextNewClass)}return[newClass,function(){for(var i=0;i<initializers.length;i++)initializers[i].call(newClass)}]}}(targetClass,classDecs)}}}}export default function applyDecs2203R(targetClass,memberDecs,classDecs){return(applyDecs2203R=applyDecs2203RFactory())(targetClass,memberDecs,classDecs)}'),
      applyDecs2301: helper("7.21.0", 'import checkInRHS from"checkInRHS";function createAddInitializerMethod(initializers,decoratorFinishedRef){return function(initializer){assertNotFinished(decoratorFinishedRef,"addInitializer"),assertCallable(initializer,"An initializer"),initializers.push(initializer)}}function assertInstanceIfPrivate(has,target){if(!has(target))throw new TypeError("Attempted to access private element on non-instance")}function memberDec(dec,name,desc,initializers,kind,isStatic,isPrivate,value,hasPrivateBrand){var kindStr;switch(kind){case 1:kindStr="accessor";break;case 2:kindStr="method";break;case 3:kindStr="getter";break;case 4:kindStr="setter";break;default:kindStr="field"}var get,set,ctx={kind:kindStr,name:isPrivate?"#"+name:name,static:isStatic,private:isPrivate},decoratorFinishedRef={v:!1};if(0!==kind&&(ctx.addInitializer=createAddInitializerMethod(initializers,decoratorFinishedRef)),isPrivate||0!==kind&&2!==kind)if(2===kind)get=function(target){return assertInstanceIfPrivate(hasPrivateBrand,target),desc.value};else{var t=0===kind||1===kind;(t||3===kind)&&(get=isPrivate?function(target){return assertInstanceIfPrivate(hasPrivateBrand,target),desc.get.call(target)}:function(target){return desc.get.call(target)}),(t||4===kind)&&(set=isPrivate?function(target,value){assertInstanceIfPrivate(hasPrivateBrand,target),desc.set.call(target,value)}:function(target,value){desc.set.call(target,value)})}else get=function(target){return target[name]},0===kind&&(set=function(target,v){target[name]=v});var has=isPrivate?hasPrivateBrand.bind():function(target){return name in target};ctx.access=get&&set?{get:get,set:set,has:has}:get?{get:get,has:has}:{set:set,has:has};try{return dec(value,ctx)}finally{decoratorFinishedRef.v=!0}}function assertNotFinished(decoratorFinishedRef,fnName){if(decoratorFinishedRef.v)throw new Error("attempted to call "+fnName+" after decoration was finished")}function assertCallable(fn,hint){if("function"!=typeof fn)throw new TypeError(hint+" must be a function")}function assertValidReturnValue(kind,value){var type=typeof value;if(1===kind){if("object"!==type||null===value)throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");void 0!==value.get&&assertCallable(value.get,"accessor.get"),void 0!==value.set&&assertCallable(value.set,"accessor.set"),void 0!==value.init&&assertCallable(value.init,"accessor.init")}else if("function"!==type){var hint;throw hint=0===kind?"field":10===kind?"class":"method",new TypeError(hint+" decorators must return a function or void 0")}}function curryThis1(fn){return function(){return fn(this)}}function curryThis2(fn){return function(value){fn(this,value)}}function applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,initializers,hasPrivateBrand){var desc,init,value,newValue,get,set,decs=decInfo[0];if(isPrivate?desc=0===kind||1===kind?{get:curryThis1(decInfo[3]),set:curryThis2(decInfo[4])}:3===kind?{get:decInfo[3]}:4===kind?{set:decInfo[3]}:{value:decInfo[3]}:0!==kind&&(desc=Object.getOwnPropertyDescriptor(base,name)),1===kind?value={get:desc.get,set:desc.set}:2===kind?value=desc.value:3===kind?value=desc.get:4===kind&&(value=desc.set),"function"==typeof decs)void 0!==(newValue=memberDec(decs,name,desc,initializers,kind,isStatic,isPrivate,value,hasPrivateBrand))&&(assertValidReturnValue(kind,newValue),0===kind?init=newValue:1===kind?(init=newValue.init,get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue);else for(var i=decs.length-1;i>=0;i--){var newInit;if(void 0!==(newValue=memberDec(decs[i],name,desc,initializers,kind,isStatic,isPrivate,value,hasPrivateBrand)))assertValidReturnValue(kind,newValue),0===kind?newInit=newValue:1===kind?(newInit=newValue.init,get=newValue.get||value.get,set=newValue.set||value.set,value={get:get,set:set}):value=newValue,void 0!==newInit&&(void 0===init?init=newInit:"function"==typeof init?init=[init,newInit]:init.push(newInit))}if(0===kind||1===kind){if(void 0===init)init=function(instance,init){return init};else if("function"!=typeof init){var ownInitializers=init;init=function(instance,init){for(var value=init,i=0;i<ownInitializers.length;i++)value=ownInitializers[i].call(instance,value);return value}}else{var originalInitializer=init;init=function(instance,init){return originalInitializer.call(instance,init)}}ret.push(init)}0!==kind&&(1===kind?(desc.get=value.get,desc.set=value.set):2===kind?desc.value=value:3===kind?desc.get=value:4===kind&&(desc.set=value),isPrivate?1===kind?(ret.push((function(instance,args){return value.get.call(instance,args)})),ret.push((function(instance,args){return value.set.call(instance,args)}))):2===kind?ret.push(value):ret.push((function(instance,args){return value.call(instance,args)})):Object.defineProperty(base,name,desc))}function applyMemberDecs(Class,decInfos,instanceBrand){for(var protoInitializers,staticInitializers,staticBrand,ret=[],existingProtoNonFields=new Map,existingStaticNonFields=new Map,i=0;i<decInfos.length;i++){var decInfo=decInfos[i];if(Array.isArray(decInfo)){var base,initializers,kind=decInfo[1],name=decInfo[2],isPrivate=decInfo.length>3,isStatic=kind>=5,hasPrivateBrand=instanceBrand;if(isStatic?(base=Class,0!==(kind-=5)&&(initializers=staticInitializers=staticInitializers||[]),isPrivate&&!staticBrand&&(staticBrand=function(_){return checkInRHS(_)===Class}),hasPrivateBrand=staticBrand):(base=Class.prototype,0!==kind&&(initializers=protoInitializers=protoInitializers||[])),0!==kind&&!isPrivate){var existingNonFields=isStatic?existingStaticNonFields:existingProtoNonFields,existingKind=existingNonFields.get(name)||0;if(!0===existingKind||3===existingKind&&4!==kind||4===existingKind&&3!==kind)throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "+name);!existingKind&&kind>2?existingNonFields.set(name,kind):existingNonFields.set(name,!0)}applyMemberDec(ret,base,decInfo,name,kind,isStatic,isPrivate,initializers,hasPrivateBrand)}}return pushInitializers(ret,protoInitializers),pushInitializers(ret,staticInitializers),ret}function pushInitializers(ret,initializers){initializers&&ret.push((function(instance){for(var i=0;i<initializers.length;i++)initializers[i].call(instance);return instance}))}function applyClassDecs(targetClass,classDecs){if(classDecs.length>0){for(var initializers=[],newClass=targetClass,name=targetClass.name,i=classDecs.length-1;i>=0;i--){var decoratorFinishedRef={v:!1};try{var nextNewClass=classDecs[i](newClass,{kind:"class",name:name,addInitializer:createAddInitializerMethod(initializers,decoratorFinishedRef)})}finally{decoratorFinishedRef.v=!0}void 0!==nextNewClass&&(assertValidReturnValue(10,nextNewClass),newClass=nextNewClass)}return[newClass,function(){for(var i=0;i<initializers.length;i++)initializers[i].call(newClass)}]}}export default function applyDecs2301(targetClass,memberDecs,classDecs,instanceBrand){return{e:applyMemberDecs(targetClass,memberDecs,instanceBrand),get c(){return applyClassDecs(targetClass,classDecs)}}}'),
      asyncGeneratorDelegate: helper("7.0.0-beta.0", 'import OverloadYield from"OverloadYield";export default function _asyncGeneratorDelegate(inner){var iter={},waiting=!1;function pump(key,value){return waiting=!0,value=new Promise((function(resolve){resolve(inner[key](value))})),{done:!1,value:new OverloadYield(value,1)}}return iter["undefined"!=typeof Symbol&&Symbol.iterator||"@@iterator"]=function(){return this},iter.next=function(value){return waiting?(waiting=!1,value):pump("next",value)},"function"==typeof inner.throw&&(iter.throw=function(value){if(waiting)throw waiting=!1,value;return pump("throw",value)}),"function"==typeof inner.return&&(iter.return=function(value){return waiting?(waiting=!1,value):pump("return",value)}),iter}'),
      asyncIterator: helper("7.15.9", 'export default function _asyncIterator(iterable){var method,async,sync,retry=2;for("undefined"!=typeof Symbol&&(async=Symbol.asyncIterator,sync=Symbol.iterator);retry--;){if(async&&null!=(method=iterable[async]))return method.call(iterable);if(sync&&null!=(method=iterable[sync]))return new AsyncFromSyncIterator(method.call(iterable));async="@@asyncIterator",sync="@@iterator"}throw new TypeError("Object is not async iterable")}function AsyncFromSyncIterator(s){function AsyncFromSyncIteratorContinuation(r){if(Object(r)!==r)return Promise.reject(new TypeError(r+" is not an object."));var done=r.done;return Promise.resolve(r.value).then((function(value){return{value:value,done:done}}))}return AsyncFromSyncIterator=function(s){this.s=s,this.n=s.next},AsyncFromSyncIterator.prototype={s:null,n:null,next:function(){return AsyncFromSyncIteratorContinuation(this.n.apply(this.s,arguments))},return:function(value){var ret=this.s.return;return void 0===ret?Promise.resolve({value:value,done:!0}):AsyncFromSyncIteratorContinuation(ret.apply(this.s,arguments))},throw:function(value){var thr=this.s.return;return void 0===thr?Promise.reject(value):AsyncFromSyncIteratorContinuation(thr.apply(this.s,arguments))}},new AsyncFromSyncIterator(s)}'),
      awaitAsyncGenerator: helper("7.0.0-beta.0", 'import OverloadYield from"OverloadYield";export default function _awaitAsyncGenerator(value){return new OverloadYield(value,0)}'),
      checkInRHS: helper("7.20.5", `export default function _checkInRHS(value){if(Object(value)!==value)throw TypeError("right-hand side of 'in' should be an object, got "+(null!==value?typeof value:"null"));return value}`),
      defineAccessor: helper("7.20.7", "export default function _defineAccessor(type,obj,key,fn){var desc={configurable:!0,enumerable:!0};return desc[type]=fn,Object.defineProperty(obj,key,desc)}"),
      iterableToArrayLimit: helper("7.0.0-beta.0", 'export default function _iterableToArrayLimit(arr,i){var _i=null==arr?null:"undefined"!=typeof Symbol&&arr[Symbol.iterator]||arr["@@iterator"];if(null!=_i){var _s,_e,_x,_r,_arr=[],_n=!0,_d=!1;try{if(_x=(_i=_i.call(arr)).next,0===i){if(Object(_i)!==_i)return;_n=!1}else for(;!(_n=(_s=_x.call(_i)).done)&&(_arr.push(_s.value),_arr.length!==i);_n=!0);}catch(err){_d=!0,_e=err}finally{try{if(!_n&&null!=_i.return&&(_r=_i.return(),Object(_r)!==_r))return}finally{if(_d)throw _e}}return _arr}}'),
      iterableToArrayLimitLoose: helper("7.0.0-beta.0", 'export default function _iterableToArrayLimitLoose(arr,i){var _i=arr&&("undefined"!=typeof Symbol&&arr[Symbol.iterator]||arr["@@iterator"]);if(null!=_i){var _s,_arr=[];for(_i=_i.call(arr);arr.length<i&&!(_s=_i.next()).done;)_arr.push(_s.value);return _arr}}'),
      jsx: helper("7.0.0-beta.0", 'var REACT_ELEMENT_TYPE;export default function _createRawReactElement(type,props,key,children){REACT_ELEMENT_TYPE||(REACT_ELEMENT_TYPE="function"==typeof Symbol&&Symbol.for&&Symbol.for("react.element")||60103);var defaultProps=type&&type.defaultProps,childrenLength=arguments.length-3;if(props||0===childrenLength||(props={children:void 0}),1===childrenLength)props.children=children;else if(childrenLength>1){for(var childArray=new Array(childrenLength),i=0;i<childrenLength;i++)childArray[i]=arguments[i+3];props.children=childArray}if(props&&defaultProps)for(var propName in defaultProps)void 0===props[propName]&&(props[propName]=defaultProps[propName]);else props||(props=defaultProps||{});return{$$typeof:REACT_ELEMENT_TYPE,type:type,key:void 0===key?null:""+key,ref:null,props:props,_owner:null}}'),
      objectSpread2: helper("7.5.0", 'import defineProperty from"defineProperty";function ownKeys(object,enumerableOnly){var keys=Object.keys(object);if(Object.getOwnPropertySymbols){var symbols=Object.getOwnPropertySymbols(object);enumerableOnly&&(symbols=symbols.filter((function(sym){return Object.getOwnPropertyDescriptor(object,sym).enumerable}))),keys.push.apply(keys,symbols)}return keys}export default function _objectSpread2(target){for(var i=1;i<arguments.length;i++){var source=null!=arguments[i]?arguments[i]:{};i%2?ownKeys(Object(source),!0).forEach((function(key){defineProperty(target,key,source[key])})):Object.getOwnPropertyDescriptors?Object.defineProperties(target,Object.getOwnPropertyDescriptors(source)):ownKeys(Object(source)).forEach((function(key){Object.defineProperty(target,key,Object.getOwnPropertyDescriptor(source,key))}))}return target}'),
      regeneratorRuntime: helper("7.18.0", `export default function _regeneratorRuntime(){"use strict";
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */_regeneratorRuntime=function(){return exports};var exports={},Op=Object.prototype,hasOwn=Op.hasOwnProperty,defineProperty=Object.defineProperty||function(obj,key,desc){obj[key]=desc.value},$Symbol="function"==typeof Symbol?Symbol:{},iteratorSymbol=$Symbol.iterator||"@@iterator",asyncIteratorSymbol=$Symbol.asyncIterator||"@@asyncIterator",toStringTagSymbol=$Symbol.toStringTag||"@@toStringTag";function define(obj,key,value){return Object.defineProperty(obj,key,{value:value,enumerable:!0,configurable:!0,writable:!0}),obj[key]}try{define({},"")}catch(err){define=function(obj,key,value){return obj[key]=value}}function wrap(innerFn,outerFn,self,tryLocsList){var protoGenerator=outerFn&&outerFn.prototype instanceof Generator?outerFn:Generator,generator=Object.create(protoGenerator.prototype),context=new Context(tryLocsList||[]);return defineProperty(generator,"_invoke",{value:makeInvokeMethod(innerFn,self,context)}),generator}function tryCatch(fn,obj,arg){try{return{type:"normal",arg:fn.call(obj,arg)}}catch(err){return{type:"throw",arg:err}}}exports.wrap=wrap;var ContinueSentinel={};function Generator(){}function GeneratorFunction(){}function GeneratorFunctionPrototype(){}var IteratorPrototype={};define(IteratorPrototype,iteratorSymbol,(function(){return this}));var getProto=Object.getPrototypeOf,NativeIteratorPrototype=getProto&&getProto(getProto(values([])));NativeIteratorPrototype&&NativeIteratorPrototype!==Op&&hasOwn.call(NativeIteratorPrototype,iteratorSymbol)&&(IteratorPrototype=NativeIteratorPrototype);var Gp=GeneratorFunctionPrototype.prototype=Generator.prototype=Object.create(IteratorPrototype);function defineIteratorMethods(prototype){["next","throw","return"].forEach((function(method){define(prototype,method,(function(arg){return this._invoke(method,arg)}))}))}function AsyncIterator(generator,PromiseImpl){function invoke(method,arg,resolve,reject){var record=tryCatch(generator[method],generator,arg);if("throw"!==record.type){var result=record.arg,value=result.value;return value&&"object"==typeof value&&hasOwn.call(value,"__await")?PromiseImpl.resolve(value.__await).then((function(value){invoke("next",value,resolve,reject)}),(function(err){invoke("throw",err,resolve,reject)})):PromiseImpl.resolve(value).then((function(unwrapped){result.value=unwrapped,resolve(result)}),(function(error){return invoke("throw",error,resolve,reject)}))}reject(record.arg)}var previousPromise;defineProperty(this,"_invoke",{value:function(method,arg){function callInvokeWithMethodAndArg(){return new PromiseImpl((function(resolve,reject){invoke(method,arg,resolve,reject)}))}return previousPromise=previousPromise?previousPromise.then(callInvokeWithMethodAndArg,callInvokeWithMethodAndArg):callInvokeWithMethodAndArg()}})}function makeInvokeMethod(innerFn,self,context){var state="suspendedStart";return function(method,arg){if("executing"===state)throw new Error("Generator is already running");if("completed"===state){if("throw"===method)throw arg;return doneResult()}for(context.method=method,context.arg=arg;;){var delegate=context.delegate;if(delegate){var delegateResult=maybeInvokeDelegate(delegate,context);if(delegateResult){if(delegateResult===ContinueSentinel)continue;return delegateResult}}if("next"===context.method)context.sent=context._sent=context.arg;else if("throw"===context.method){if("suspendedStart"===state)throw state="completed",context.arg;context.dispatchException(context.arg)}else"return"===context.method&&context.abrupt("return",context.arg);state="executing";var record=tryCatch(innerFn,self,context);if("normal"===record.type){if(state=context.done?"completed":"suspendedYield",record.arg===ContinueSentinel)continue;return{value:record.arg,done:context.done}}"throw"===record.type&&(state="completed",context.method="throw",context.arg=record.arg)}}}function maybeInvokeDelegate(delegate,context){var methodName=context.method,method=delegate.iterator[methodName];if(undefined===method)return context.delegate=null,"throw"===methodName&&delegate.iterator.return&&(context.method="return",context.arg=undefined,maybeInvokeDelegate(delegate,context),"throw"===context.method)||"return"!==methodName&&(context.method="throw",context.arg=new TypeError("The iterator does not provide a '"+methodName+"' method")),ContinueSentinel;var record=tryCatch(method,delegate.iterator,context.arg);if("throw"===record.type)return context.method="throw",context.arg=record.arg,context.delegate=null,ContinueSentinel;var info=record.arg;return info?info.done?(context[delegate.resultName]=info.value,context.next=delegate.nextLoc,"return"!==context.method&&(context.method="next",context.arg=undefined),context.delegate=null,ContinueSentinel):info:(context.method="throw",context.arg=new TypeError("iterator result is not an object"),context.delegate=null,ContinueSentinel)}function pushTryEntry(locs){var entry={tryLoc:locs[0]};1 in locs&&(entry.catchLoc=locs[1]),2 in locs&&(entry.finallyLoc=locs[2],entry.afterLoc=locs[3]),this.tryEntries.push(entry)}function resetTryEntry(entry){var record=entry.completion||{};record.type="normal",delete record.arg,entry.completion=record}function Context(tryLocsList){this.tryEntries=[{tryLoc:"root"}],tryLocsList.forEach(pushTryEntry,this),this.reset(!0)}function values(iterable){if(iterable){var iteratorMethod=iterable[iteratorSymbol];if(iteratorMethod)return iteratorMethod.call(iterable);if("function"==typeof iterable.next)return iterable;if(!isNaN(iterable.length)){var i=-1,next=function next(){for(;++i<iterable.length;)if(hasOwn.call(iterable,i))return next.value=iterable[i],next.done=!1,next;return next.value=undefined,next.done=!0,next};return next.next=next}}return{next:doneResult}}function doneResult(){return{value:undefined,done:!0}}return GeneratorFunction.prototype=GeneratorFunctionPrototype,defineProperty(Gp,"constructor",{value:GeneratorFunctionPrototype,configurable:!0}),defineProperty(GeneratorFunctionPrototype,"constructor",{value:GeneratorFunction,configurable:!0}),GeneratorFunction.displayName=define(GeneratorFunctionPrototype,toStringTagSymbol,"GeneratorFunction"),exports.isGeneratorFunction=function(genFun){var ctor="function"==typeof genFun&&genFun.constructor;return!!ctor&&(ctor===GeneratorFunction||"GeneratorFunction"===(ctor.displayName||ctor.name))},exports.mark=function(genFun){return Object.setPrototypeOf?Object.setPrototypeOf(genFun,GeneratorFunctionPrototype):(genFun.__proto__=GeneratorFunctionPrototype,define(genFun,toStringTagSymbol,"GeneratorFunction")),genFun.prototype=Object.create(Gp),genFun},exports.awrap=function(arg){return{__await:arg}},defineIteratorMethods(AsyncIterator.prototype),define(AsyncIterator.prototype,asyncIteratorSymbol,(function(){return this})),exports.AsyncIterator=AsyncIterator,exports.async=function(innerFn,outerFn,self,tryLocsList,PromiseImpl){void 0===PromiseImpl&&(PromiseImpl=Promise);var iter=new AsyncIterator(wrap(innerFn,outerFn,self,tryLocsList),PromiseImpl);return exports.isGeneratorFunction(outerFn)?iter:iter.next().then((function(result){return result.done?result.value:iter.next()}))},defineIteratorMethods(Gp),define(Gp,toStringTagSymbol,"Generator"),define(Gp,iteratorSymbol,(function(){return this})),define(Gp,"toString",(function(){return"[object Generator]"})),exports.keys=function(val){var object=Object(val),keys=[];for(var key in object)keys.push(key);return keys.reverse(),function next(){for(;keys.length;){var key=keys.pop();if(key in object)return next.value=key,next.done=!1,next}return next.done=!0,next}},exports.values=values,Context.prototype={constructor:Context,reset:function(skipTempReset){if(this.prev=0,this.next=0,this.sent=this._sent=undefined,this.done=!1,this.delegate=null,this.method="next",this.arg=undefined,this.tryEntries.forEach(resetTryEntry),!skipTempReset)for(var name in this)"t"===name.charAt(0)&&hasOwn.call(this,name)&&!isNaN(+name.slice(1))&&(this[name]=undefined)},stop:function(){this.done=!0;var rootRecord=this.tryEntries[0].completion;if("throw"===rootRecord.type)throw rootRecord.arg;return this.rval},dispatchException:function(exception){if(this.done)throw exception;var context=this;function handle(loc,caught){return record.type="throw",record.arg=exception,context.next=loc,caught&&(context.method="next",context.arg=undefined),!!caught}for(var i=this.tryEntries.length-1;i>=0;--i){var entry=this.tryEntries[i],record=entry.completion;if("root"===entry.tryLoc)return handle("end");if(entry.tryLoc<=this.prev){var hasCatch=hasOwn.call(entry,"catchLoc"),hasFinally=hasOwn.call(entry,"finallyLoc");if(hasCatch&&hasFinally){if(this.prev<entry.catchLoc)return handle(entry.catchLoc,!0);if(this.prev<entry.finallyLoc)return handle(entry.finallyLoc)}else if(hasCatch){if(this.prev<entry.catchLoc)return handle(entry.catchLoc,!0)}else{if(!hasFinally)throw new Error("try statement without catch or finally");if(this.prev<entry.finallyLoc)return handle(entry.finallyLoc)}}}},abrupt:function(type,arg){for(var i=this.tryEntries.length-1;i>=0;--i){var entry=this.tryEntries[i];if(entry.tryLoc<=this.prev&&hasOwn.call(entry,"finallyLoc")&&this.prev<entry.finallyLoc){var finallyEntry=entry;break}}finallyEntry&&("break"===type||"continue"===type)&&finallyEntry.tryLoc<=arg&&arg<=finallyEntry.finallyLoc&&(finallyEntry=null);var record=finallyEntry?finallyEntry.completion:{};return record.type=type,record.arg=arg,finallyEntry?(this.method="next",this.next=finallyEntry.finallyLoc,ContinueSentinel):this.complete(record)},complete:function(record,afterLoc){if("throw"===record.type)throw record.arg;return"break"===record.type||"continue"===record.type?this.next=record.arg:"return"===record.type?(this.rval=this.arg=record.arg,this.method="return",this.next="end"):"normal"===record.type&&afterLoc&&(this.next=afterLoc),ContinueSentinel},finish:function(finallyLoc){for(var i=this.tryEntries.length-1;i>=0;--i){var entry=this.tryEntries[i];if(entry.finallyLoc===finallyLoc)return this.complete(entry.completion,entry.afterLoc),resetTryEntry(entry),ContinueSentinel}},catch:function(tryLoc){for(var i=this.tryEntries.length-1;i>=0;--i){var entry=this.tryEntries[i];if(entry.tryLoc===tryLoc){var record=entry.completion;if("throw"===record.type){var thrown=record.arg;resetTryEntry(entry)}return thrown}}throw new Error("illegal catch attempt")},delegateYield:function(iterable,resultName,nextLoc){return this.delegate={iterator:values(iterable),resultName:resultName,nextLoc:nextLoc},"next"===this.method&&(this.arg=undefined),ContinueSentinel}},exports}`),
      typeof: helper("7.0.0-beta.0", 'export default function _typeof(obj){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(obj){return typeof obj}:function(obj){return obj&&"function"==typeof Symbol&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj},_typeof(obj)}'),
      wrapRegExp: helper("7.19.0", 'import setPrototypeOf from"setPrototypeOf";import inherits from"inherits";export default function _wrapRegExp(){_wrapRegExp=function(re,groups){return new BabelRegExp(re,void 0,groups)};var _super=RegExp.prototype,_groups=new WeakMap;function BabelRegExp(re,flags,groups){var _this=new RegExp(re,flags);return _groups.set(_this,groups||_groups.get(re)),setPrototypeOf(_this,BabelRegExp.prototype)}function buildGroups(result,re){var g=_groups.get(re);return Object.keys(g).reduce((function(groups,name){var i=g[name];if("number"==typeof i)groups[name]=result[i];else{for(var k=0;void 0===result[i[k]]&&k+1<i.length;)k++;groups[name]=result[i[k]]}return groups}),Object.create(null))}return inherits(BabelRegExp,RegExp),BabelRegExp.prototype.exec=function(str){var result=_super.exec.call(this,str);if(result){result.groups=buildGroups(result,this);var indices=result.indices;indices&&(indices.groups=buildGroups(indices,this))}return result},BabelRegExp.prototype[Symbol.replace]=function(str,substitution){if("string"==typeof substitution){var groups=_groups.get(this);return _super[Symbol.replace].call(this,str,substitution.replace(/\\$<([^>]+)>/g,(function(_,name){var group=groups[name];return"$"+(Array.isArray(group)?group.join("$"):group)})))}if("function"==typeof substitution){var _this=this;return _super[Symbol.replace].call(this,str,(function(){var args=arguments;return"object"!=typeof args[args.length-1]&&(args=[].slice.call(args)).push(buildGroups(args,_this)),substitution.apply(this,args)}))}return _super[Symbol.replace].call(this,str,substitution)},_wrapRegExp.apply(this,arguments)}')
    });
    exports.default = _default;
  }
});

// node_modules/@babel/helpers/lib/helpers.js
var require_helpers = __commonJS({
  "node_modules/@babel/helpers/lib/helpers.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _template = require_lib11();
    var _helpersGenerated = require_helpers_generated();
    var helpers = Object.assign({
      __proto__: null
    }, _helpersGenerated.default);
    var _default = helpers;
    exports.default = _default;
    var helper = (minVersion) => (tpl) => ({
      minVersion,
      ast: () => _template.default.program.ast(tpl)
    });
    {
      helpers.AwaitValue = helper("7.0.0-beta.0")`
    export default function _AwaitValue(value) {
      this.wrapped = value;
    }
  `;
    }
    helpers.wrapAsyncGenerator = helper("7.0.0-beta.0")`
  import AsyncGenerator from "AsyncGenerator";

  export default function _wrapAsyncGenerator(fn) {
    return function () {
      return new AsyncGenerator(fn.apply(this, arguments));
    };
  }
`;
    helpers.asyncToGenerator = helper("7.0.0-beta.0")`
  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
      var info = gen[key](arg);
      var value = info.value;
    } catch (error) {
      reject(error);
      return;
    }

    if (info.done) {
      resolve(value);
    } else {
      Promise.resolve(value).then(_next, _throw);
    }
  }

  export default function _asyncToGenerator(fn) {
    return function () {
      var self = this, args = arguments;
      return new Promise(function (resolve, reject) {
        var gen = fn.apply(self, args);
        function _next(value) {
          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
        }
        function _throw(err) {
          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
        }

        _next(undefined);
      });
    };
  }
`;
    helpers.classCallCheck = helper("7.0.0-beta.0")`
  export default function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
`;
    helpers.createClass = helper("7.0.0-beta.0")`
  import toPropertyKey from "toPropertyKey";
  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i ++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
    }
  }

  export default function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    Object.defineProperty(Constructor, "prototype", { writable: false });
    return Constructor;
  }
`;
    helpers.defineEnumerableProperties = helper("7.0.0-beta.0")`
  export default function _defineEnumerableProperties(obj, descs) {
    for (var key in descs) {
      var desc = descs[key];
      desc.configurable = desc.enumerable = true;
      if ("value" in desc) desc.writable = true;
      Object.defineProperty(obj, key, desc);
    }

    // Symbols are not enumerated over by for-in loops. If native
    // Symbols are available, fetch all of the descs object's own
    // symbol properties and define them on our target object too.
    if (Object.getOwnPropertySymbols) {
      var objectSymbols = Object.getOwnPropertySymbols(descs);
      for (var i = 0; i < objectSymbols.length; i++) {
        var sym = objectSymbols[i];
        var desc = descs[sym];
        desc.configurable = desc.enumerable = true;
        if ("value" in desc) desc.writable = true;
        Object.defineProperty(obj, sym, desc);
      }
    }
    return obj;
  }
`;
    helpers.defaults = helper("7.0.0-beta.0")`
  export default function _defaults(obj, defaults) {
    var keys = Object.getOwnPropertyNames(defaults);
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      var value = Object.getOwnPropertyDescriptor(defaults, key);
      if (value && value.configurable && obj[key] === undefined) {
        Object.defineProperty(obj, key, value);
      }
    }
    return obj;
  }
`;
    helpers.defineProperty = helper("7.0.0-beta.0")`
  import toPropertyKey from "toPropertyKey";
  export default function _defineProperty(obj, key, value) {
    key = toPropertyKey(key);
    // Shortcircuit the slow defineProperty path when possible.
    // We are trying to avoid issues where setters defined on the
    // prototype cause side effects under the fast path of simple
    // assignment. By checking for existence of the property with
    // the in operator, we can optimize most of this overhead away.
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
    return obj;
  }
`;
    helpers.extends = helper("7.0.0-beta.0")`
  export default function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
      return target;
    };

    return _extends.apply(this, arguments);
  }
`;
    helpers.objectSpread = helper("7.0.0-beta.0")`
  import defineProperty from "defineProperty";

  export default function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = (arguments[i] != null) ? Object(arguments[i]) : {};
      var ownKeys = Object.keys(source);
      if (typeof Object.getOwnPropertySymbols === 'function') {
        ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function(sym) {
          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
        }));
      }
      ownKeys.forEach(function(key) {
        defineProperty(target, key, source[key]);
      });
    }
    return target;
  }
`;
    helpers.inherits = helper("7.0.0-beta.0")`
  import setPrototypeOf from "setPrototypeOf";

  export default function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }
    // We can't use defineProperty to set the prototype in a single step because it
    // doesn't work in Chrome <= 36. https://github.com/babel/babel/issues/14056
    // V8 bug: https://bugs.chromium.org/p/v8/issues/detail?id=3334
    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    Object.defineProperty(subClass, "prototype", { writable: false });
    if (superClass) setPrototypeOf(subClass, superClass);
  }
`;
    helpers.inheritsLoose = helper("7.0.0-beta.0")`
  import setPrototypeOf from "setPrototypeOf";

  export default function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    setPrototypeOf(subClass, superClass);
  }
`;
    helpers.getPrototypeOf = helper("7.0.0-beta.0")`
  export default function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf
      ? Object.getPrototypeOf.bind()
      : function _getPrototypeOf(o) {
          return o.__proto__ || Object.getPrototypeOf(o);
        };
    return _getPrototypeOf(o);
  }
`;
    helpers.setPrototypeOf = helper("7.0.0-beta.0")`
  export default function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf
      ? Object.setPrototypeOf.bind()
      : function _setPrototypeOf(o, p) {
          o.__proto__ = p;
          return o;
        };
    return _setPrototypeOf(o, p);
  }
`;
    helpers.isNativeReflectConstruct = helper("7.9.0")`
  export default function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;

    // core-js@3
    if (Reflect.construct.sham) return false;

    // Proxy can't be polyfilled. Every browser implemented
    // proxies before or at the same time as Reflect.construct,
    // so if they support Proxy they also support Reflect.construct.
    if (typeof Proxy === "function") return true;

    // Since Reflect.construct can't be properly polyfilled, some
    // implementations (e.g. core-js@2) don't set the correct internal slots.
    // Those polyfills don't allow us to subclass built-ins, so we need to
    // use our fallback implementation.
    try {
      // If the internal slots aren't set, this throws an error similar to
      //   TypeError: this is not a Boolean object.

      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
      return true;
    } catch (e) {
      return false;
    }
  }
`;
    helpers.construct = helper("7.0.0-beta.0")`
  import setPrototypeOf from "setPrototypeOf";
  import isNativeReflectConstruct from "isNativeReflectConstruct";

  export default function _construct(Parent, args, Class) {
    if (isNativeReflectConstruct()) {
      _construct = Reflect.construct.bind();
    } else {
      // NOTE: If Parent !== Class, the correct __proto__ is set *after*
      //       calling the constructor.
      _construct = function _construct(Parent, args, Class) {
        var a = [null];
        a.push.apply(a, args);
        var Constructor = Function.bind.apply(Parent, a);
        var instance = new Constructor();
        if (Class) setPrototypeOf(instance, Class.prototype);
        return instance;
      };
    }
    // Avoid issues with Class being present but undefined when it wasn't
    // present in the original call.
    return _construct.apply(null, arguments);
  }
`;
    helpers.isNativeFunction = helper("7.0.0-beta.0")`
  export default function _isNativeFunction(fn) {
    // Note: This function returns "true" for core-js functions.
    return Function.toString.call(fn).indexOf("[native code]") !== -1;
  }
`;
    helpers.wrapNativeSuper = helper("7.0.0-beta.0")`
  import getPrototypeOf from "getPrototypeOf";
  import setPrototypeOf from "setPrototypeOf";
  import isNativeFunction from "isNativeFunction";
  import construct from "construct";

  export default function _wrapNativeSuper(Class) {
    var _cache = typeof Map === "function" ? new Map() : undefined;

    _wrapNativeSuper = function _wrapNativeSuper(Class) {
      if (Class === null || !isNativeFunction(Class)) return Class;
      if (typeof Class !== "function") {
        throw new TypeError("Super expression must either be null or a function");
      }
      if (typeof _cache !== "undefined") {
        if (_cache.has(Class)) return _cache.get(Class);
        _cache.set(Class, Wrapper);
      }
      function Wrapper() {
        return construct(Class, arguments, getPrototypeOf(this).constructor)
      }
      Wrapper.prototype = Object.create(Class.prototype, {
        constructor: {
          value: Wrapper,
          enumerable: false,
          writable: true,
          configurable: true,
        }
      });

      return setPrototypeOf(Wrapper, Class);
    }

    return _wrapNativeSuper(Class)
  }
`;
    helpers.instanceof = helper("7.0.0-beta.0")`
  export default function _instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
      return !!right[Symbol.hasInstance](left);
    } else {
      return left instanceof right;
    }
  }
`;
    helpers.interopRequireDefault = helper("7.0.0-beta.0")`
  export default function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }
`;
    helpers.interopRequireWildcard = helper("7.14.0")`
  function _getRequireWildcardCache(nodeInterop) {
    if (typeof WeakMap !== "function") return null;

    var cacheBabelInterop = new WeakMap();
    var cacheNodeInterop = new WeakMap();
    return (_getRequireWildcardCache = function (nodeInterop) {
      return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
    })(nodeInterop);
  }

  export default function _interopRequireWildcard(obj, nodeInterop) {
    if (!nodeInterop && obj && obj.__esModule) {
      return obj;
    }

    if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
      return { default: obj }
    }

    var cache = _getRequireWildcardCache(nodeInterop);
    if (cache && cache.has(obj)) {
      return cache.get(obj);
    }

    var newObj = {};
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
    for (var key in obj) {
      if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
        var desc = hasPropertyDescriptor
          ? Object.getOwnPropertyDescriptor(obj, key)
          : null;
        if (desc && (desc.get || desc.set)) {
          Object.defineProperty(newObj, key, desc);
        } else {
          newObj[key] = obj[key];
        }
      }
    }
    newObj.default = obj;
    if (cache) {
      cache.set(obj, newObj);
    }
    return newObj;
  }
`;
    helpers.newArrowCheck = helper("7.0.0-beta.0")`
  export default function _newArrowCheck(innerThis, boundThis) {
    if (innerThis !== boundThis) {
      throw new TypeError("Cannot instantiate an arrow function");
    }
  }
`;
    helpers.objectDestructuringEmpty = helper("7.0.0-beta.0")`
  export default function _objectDestructuringEmpty(obj) {
    if (obj == null) throw new TypeError("Cannot destructure " + obj);
  }
`;
    helpers.objectWithoutPropertiesLoose = helper("7.0.0-beta.0")`
  export default function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};

    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;

    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }

    return target;
  }
`;
    helpers.objectWithoutProperties = helper("7.0.0-beta.0")`
  import objectWithoutPropertiesLoose from "objectWithoutPropertiesLoose";

  export default function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};

    var target = objectWithoutPropertiesLoose(source, excluded);
    var key, i;

    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }

    return target;
  }
`;
    helpers.assertThisInitialized = helper("7.0.0-beta.0")`
  export default function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
  }
`;
    helpers.possibleConstructorReturn = helper("7.0.0-beta.0")`
  import assertThisInitialized from "assertThisInitialized";

  export default function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    } else if (call !== void 0) {
      throw new TypeError("Derived constructors may only return object or undefined");
    }

    return assertThisInitialized(self);
  }
`;
    helpers.createSuper = helper("7.9.0")`
  import getPrototypeOf from "getPrototypeOf";
  import isNativeReflectConstruct from "isNativeReflectConstruct";
  import possibleConstructorReturn from "possibleConstructorReturn";

  export default function _createSuper(Derived) {
    var hasNativeReflectConstruct = isNativeReflectConstruct();

    return function _createSuperInternal() {
      var Super = getPrototypeOf(Derived), result;
      if (hasNativeReflectConstruct) {
        // NOTE: This doesn't work if this.__proto__.constructor has been modified.
        var NewTarget = getPrototypeOf(this).constructor;
        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }
      return possibleConstructorReturn(this, result);
    }
  }
 `;
    helpers.superPropBase = helper("7.0.0-beta.0")`
  import getPrototypeOf from "getPrototypeOf";

  export default function _superPropBase(object, property) {
    // Yes, this throws if object is null to being with, that's on purpose.
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = getPrototypeOf(object);
      if (object === null) break;
    }
    return object;
  }
`;
    helpers.get = helper("7.0.0-beta.0")`
  import superPropBase from "superPropBase";

  export default function _get() {
    if (typeof Reflect !== "undefined" && Reflect.get) {
      _get = Reflect.get.bind();
    } else {
      _get = function _get(target, property, receiver) {
        var base = superPropBase(target, property);

        if (!base) return;

        var desc = Object.getOwnPropertyDescriptor(base, property);
        if (desc.get) {
          // STEP 3. If receiver is not present, then set receiver to target.
          return desc.get.call(arguments.length < 3 ? target : receiver);
        }

        return desc.value;
      };
    }
    return _get.apply(this, arguments);
  }
`;
    helpers.set = helper("7.0.0-beta.0")`
  import superPropBase from "superPropBase";
  import defineProperty from "defineProperty";

  function set(target, property, value, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.set) {
      set = Reflect.set;
    } else {
      set = function set(target, property, value, receiver) {
        var base = superPropBase(target, property);
        var desc;

        if (base) {
          desc = Object.getOwnPropertyDescriptor(base, property);
          if (desc.set) {
            desc.set.call(receiver, value);
            return true;
          } else if (!desc.writable) {
            // Both getter and non-writable fall into this.
            return false;
          }
        }

        // Without a super that defines the property, spec boils down to
        // "define on receiver" for some reason.
        desc = Object.getOwnPropertyDescriptor(receiver, property);
        if (desc) {
          if (!desc.writable) {
            // Setter, getter, and non-writable fall into this.
            return false;
          }

          desc.value = value;
          Object.defineProperty(receiver, property, desc);
        } else {
          // Avoid setters that may be defined on Sub's prototype, but not on
          // the instance.
          defineProperty(receiver, property, value);
        }

        return true;
      };
    }

    return set(target, property, value, receiver);
  }

  export default function _set(target, property, value, receiver, isStrict) {
    var s = set(target, property, value, receiver || target);
    if (!s && isStrict) {
      throw new TypeError('failed to set property');
    }

    return value;
  }
`;
    helpers.taggedTemplateLiteral = helper("7.0.0-beta.0")`
  export default function _taggedTemplateLiteral(strings, raw) {
    if (!raw) { raw = strings.slice(0); }
    return Object.freeze(Object.defineProperties(strings, {
        raw: { value: Object.freeze(raw) }
    }));
  }
`;
    helpers.taggedTemplateLiteralLoose = helper("7.0.0-beta.0")`
  export default function _taggedTemplateLiteralLoose(strings, raw) {
    if (!raw) { raw = strings.slice(0); }
    strings.raw = raw;
    return strings;
  }
`;
    helpers.readOnlyError = helper("7.0.0-beta.0")`
  export default function _readOnlyError(name) {
    throw new TypeError("\\"" + name + "\\" is read-only");
  }
`;
    helpers.writeOnlyError = helper("7.12.13")`
  export default function _writeOnlyError(name) {
    throw new TypeError("\\"" + name + "\\" is write-only");
  }
`;
    helpers.classNameTDZError = helper("7.0.0-beta.0")`
  export default function _classNameTDZError(name) {
    throw new ReferenceError("Class \\"" + name + "\\" cannot be referenced in computed property keys.");
  }
`;
    helpers.temporalUndefined = helper("7.0.0-beta.0")`
  // This function isn't mean to be called, but to be used as a reference.
  // We can't use a normal object because it isn't hoisted.
  export default function _temporalUndefined() {}
`;
    helpers.tdz = helper("7.5.5")`
  export default function _tdzError(name) {
    throw new ReferenceError(name + " is not defined - temporal dead zone");
  }
`;
    helpers.temporalRef = helper("7.0.0-beta.0")`
  import undef from "temporalUndefined";
  import err from "tdz";

  export default function _temporalRef(val, name) {
    return val === undef ? err(name) : val;
  }
`;
    helpers.slicedToArray = helper("7.0.0-beta.0")`
  import arrayWithHoles from "arrayWithHoles";
  import iterableToArrayLimit from "iterableToArrayLimit";
  import unsupportedIterableToArray from "unsupportedIterableToArray";
  import nonIterableRest from "nonIterableRest";

  export default function _slicedToArray(arr, i) {
    return (
      arrayWithHoles(arr) ||
      iterableToArrayLimit(arr, i) ||
      unsupportedIterableToArray(arr, i) ||
      nonIterableRest()
    );
  }
`;
    helpers.slicedToArrayLoose = helper("7.0.0-beta.0")`
  import arrayWithHoles from "arrayWithHoles";
  import iterableToArrayLimitLoose from "iterableToArrayLimitLoose";
  import unsupportedIterableToArray from "unsupportedIterableToArray";
  import nonIterableRest from "nonIterableRest";

  export default function _slicedToArrayLoose(arr, i) {
    return (
      arrayWithHoles(arr) ||
      iterableToArrayLimitLoose(arr, i) ||
      unsupportedIterableToArray(arr, i) ||
      nonIterableRest()
    );
  }
`;
    helpers.toArray = helper("7.0.0-beta.0")`
  import arrayWithHoles from "arrayWithHoles";
  import iterableToArray from "iterableToArray";
  import unsupportedIterableToArray from "unsupportedIterableToArray";
  import nonIterableRest from "nonIterableRest";

  export default function _toArray(arr) {
    return (
      arrayWithHoles(arr) ||
      iterableToArray(arr) ||
      unsupportedIterableToArray(arr) ||
      nonIterableRest()
    );
  }
`;
    helpers.toConsumableArray = helper("7.0.0-beta.0")`
  import arrayWithoutHoles from "arrayWithoutHoles";
  import iterableToArray from "iterableToArray";
  import unsupportedIterableToArray from "unsupportedIterableToArray";
  import nonIterableSpread from "nonIterableSpread";

  export default function _toConsumableArray(arr) {
    return (
      arrayWithoutHoles(arr) ||
      iterableToArray(arr) ||
      unsupportedIterableToArray(arr) ||
      nonIterableSpread()
    );
  }
`;
    helpers.arrayWithoutHoles = helper("7.0.0-beta.0")`
  import arrayLikeToArray from "arrayLikeToArray";

  export default function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return arrayLikeToArray(arr);
  }
`;
    helpers.arrayWithHoles = helper("7.0.0-beta.0")`
  export default function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }
`;
    helpers.maybeArrayLike = helper("7.9.0")`
  import arrayLikeToArray from "arrayLikeToArray";

  export default function _maybeArrayLike(next, arr, i) {
    if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
      var len = arr.length;
      return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len);
    }
    return next(arr, i);
  }
`;
    helpers.iterableToArray = helper("7.0.0-beta.0")`
  export default function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
  }
`;
    helpers.unsupportedIterableToArray = helper("7.9.0")`
  import arrayLikeToArray from "arrayLikeToArray";

  export default function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
      return arrayLikeToArray(o, minLen);
  }
`;
    helpers.arrayLikeToArray = helper("7.9.0")`
  export default function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
    return arr2;
  }
`;
    helpers.nonIterableSpread = helper("7.0.0-beta.0")`
  export default function _nonIterableSpread() {
    throw new TypeError(
      "Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
    );
  }
`;
    helpers.nonIterableRest = helper("7.0.0-beta.0")`
  export default function _nonIterableRest() {
    throw new TypeError(
      "Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
    );
  }
`;
    helpers.createForOfIteratorHelper = helper("7.9.0")`
  import unsupportedIterableToArray from "unsupportedIterableToArray";

  // s: start (create the iterator)
  // n: next
  // e: error (called whenever something throws)
  // f: finish (always called at the end)

  export default function _createForOfIteratorHelper(o, allowArrayLike) {
    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];

    if (!it) {
      // Fallback for engines without symbol support
      if (
        Array.isArray(o) ||
        (it = unsupportedIterableToArray(o)) ||
        (allowArrayLike && o && typeof o.length === "number")
      ) {
        if (it) o = it;
        var i = 0;
        var F = function(){};
        return {
          s: F,
          n: function() {
            if (i >= o.length) return { done: true };
            return { done: false, value: o[i++] };
          },
          e: function(e) { throw e; },
          f: F,
        };
      }

      throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }

    var normalCompletion = true, didErr = false, err;

    return {
      s: function() {
        it = it.call(o);
      },
      n: function() {
        var step = it.next();
        normalCompletion = step.done;
        return step;
      },
      e: function(e) {
        didErr = true;
        err = e;
      },
      f: function() {
        try {
          if (!normalCompletion && it.return != null) it.return();
        } finally {
          if (didErr) throw err;
        }
      }
    };
  }
`;
    helpers.createForOfIteratorHelperLoose = helper("7.9.0")`
  import unsupportedIterableToArray from "unsupportedIterableToArray";

  export default function _createForOfIteratorHelperLoose(o, allowArrayLike) {
    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];

    if (it) return (it = it.call(o)).next.bind(it);

    // Fallback for engines without symbol support
    if (
      Array.isArray(o) ||
      (it = unsupportedIterableToArray(o)) ||
      (allowArrayLike && o && typeof o.length === "number")
    ) {
      if (it) o = it;
      var i = 0;
      return function() {
        if (i >= o.length) return { done: true };
        return { done: false, value: o[i++] };
      }
    }

    throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
`;
    helpers.skipFirstGeneratorNext = helper("7.0.0-beta.0")`
  export default function _skipFirstGeneratorNext(fn) {
    return function () {
      var it = fn.apply(this, arguments);
      it.next();
      return it;
    }
  }
`;
    helpers.toPrimitive = helper("7.1.5")`
  export default function _toPrimitive(
    input,
    hint /*: "default" | "string" | "number" | void */
  ) {
    if (typeof input !== "object" || input === null) return input;
    var prim = input[Symbol.toPrimitive];
    if (prim !== undefined) {
      var res = prim.call(input, hint || "default");
      if (typeof res !== "object") return res;
      throw new TypeError("@@toPrimitive must return a primitive value.");
    }
    return (hint === "string" ? String : Number)(input);
  }
`;
    helpers.toPropertyKey = helper("7.1.5")`
  import toPrimitive from "toPrimitive";

  export default function _toPropertyKey(arg) {
    var key = toPrimitive(arg, "string");
    return typeof key === "symbol" ? key : String(key);
  }
`;
    helpers.initializerWarningHelper = helper("7.0.0-beta.0")`
    export default function _initializerWarningHelper(descriptor, context){
        throw new Error(
          'Decorating class property failed. Please ensure that ' +
          'proposal-class-properties is enabled and runs after the decorators transform.'
        );
    }
`;
    helpers.initializerDefineProperty = helper("7.0.0-beta.0")`
    export default function _initializerDefineProperty(target, property, descriptor, context){
        if (!descriptor) return;

        Object.defineProperty(target, property, {
            enumerable: descriptor.enumerable,
            configurable: descriptor.configurable,
            writable: descriptor.writable,
            value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,
        });
    }
`;
    helpers.applyDecoratedDescriptor = helper("7.0.0-beta.0")`
    export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){
        var desc = {};
        Object.keys(descriptor).forEach(function(key){
            desc[key] = descriptor[key];
        });
        desc.enumerable = !!desc.enumerable;
        desc.configurable = !!desc.configurable;
        if ('value' in desc || desc.initializer){
            desc.writable = true;
        }

        desc = decorators.slice().reverse().reduce(function(desc, decorator){
            return decorator(target, property, desc) || desc;
        }, desc);

        if (context && desc.initializer !== void 0){
            desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
            desc.initializer = undefined;
        }

        if (desc.initializer === void 0){
            Object.defineProperty(target, property, desc);
            desc = null;
        }

        return desc;
    }
`;
    helpers.classPrivateFieldLooseKey = helper("7.0.0-beta.0")`
  var id = 0;
  export default function _classPrivateFieldKey(name) {
    return "__private_" + (id++) + "_" + name;
  }
`;
    helpers.classPrivateFieldLooseBase = helper("7.0.0-beta.0")`
  export default function _classPrivateFieldBase(receiver, privateKey) {
    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
      throw new TypeError("attempted to use private field on non-instance");
    }
    return receiver;
  }
`;
    helpers.classPrivateFieldGet = helper("7.0.0-beta.0")`
  import classApplyDescriptorGet from "classApplyDescriptorGet";
  import classExtractFieldDescriptor from "classExtractFieldDescriptor";
  export default function _classPrivateFieldGet(receiver, privateMap) {
    var descriptor = classExtractFieldDescriptor(receiver, privateMap, "get");
    return classApplyDescriptorGet(receiver, descriptor);
  }
`;
    helpers.classPrivateFieldSet = helper("7.0.0-beta.0")`
  import classApplyDescriptorSet from "classApplyDescriptorSet";
  import classExtractFieldDescriptor from "classExtractFieldDescriptor";
  export default function _classPrivateFieldSet(receiver, privateMap, value) {
    var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
    classApplyDescriptorSet(receiver, descriptor, value);
    return value;
  }
`;
    helpers.classPrivateFieldDestructureSet = helper("7.4.4")`
  import classApplyDescriptorDestructureSet from "classApplyDescriptorDestructureSet";
  import classExtractFieldDescriptor from "classExtractFieldDescriptor";
  export default function _classPrivateFieldDestructureSet(receiver, privateMap) {
    var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
    return classApplyDescriptorDestructureSet(receiver, descriptor);
  }
`;
    helpers.classExtractFieldDescriptor = helper("7.13.10")`
  export default function _classExtractFieldDescriptor(receiver, privateMap, action) {
    if (!privateMap.has(receiver)) {
      throw new TypeError("attempted to " + action + " private field on non-instance");
    }
    return privateMap.get(receiver);
  }
`;
    helpers.classStaticPrivateFieldSpecGet = helper("7.0.2")`
  import classApplyDescriptorGet from "classApplyDescriptorGet";
  import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess";
  import classCheckPrivateStaticFieldDescriptor from "classCheckPrivateStaticFieldDescriptor";
  export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
    classCheckPrivateStaticAccess(receiver, classConstructor);
    classCheckPrivateStaticFieldDescriptor(descriptor, "get");
    return classApplyDescriptorGet(receiver, descriptor);
  }
`;
    helpers.classStaticPrivateFieldSpecSet = helper("7.0.2")`
  import classApplyDescriptorSet from "classApplyDescriptorSet";
  import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess";
  import classCheckPrivateStaticFieldDescriptor from "classCheckPrivateStaticFieldDescriptor";
  export default function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
    classCheckPrivateStaticAccess(receiver, classConstructor);
    classCheckPrivateStaticFieldDescriptor(descriptor, "set");
    classApplyDescriptorSet(receiver, descriptor, value);
    return value;
  }
`;
    helpers.classStaticPrivateMethodGet = helper("7.3.2")`
  import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess";
  export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
    classCheckPrivateStaticAccess(receiver, classConstructor);
    return method;
  }
`;
    helpers.classStaticPrivateMethodSet = helper("7.3.2")`
  export default function _classStaticPrivateMethodSet() {
    throw new TypeError("attempted to set read only static private field");
  }
`;
    helpers.classApplyDescriptorGet = helper("7.13.10")`
  export default function _classApplyDescriptorGet(receiver, descriptor) {
    if (descriptor.get) {
      return descriptor.get.call(receiver);
    }
    return descriptor.value;
  }
`;
    helpers.classApplyDescriptorSet = helper("7.13.10")`
  export default function _classApplyDescriptorSet(receiver, descriptor, value) {
    if (descriptor.set) {
      descriptor.set.call(receiver, value);
    } else {
      if (!descriptor.writable) {
        // This should only throw in strict mode, but class bodies are
        // always strict and private fields can only be used inside
        // class bodies.
        throw new TypeError("attempted to set read only private field");
      }
      descriptor.value = value;
    }
  }
`;
    helpers.classApplyDescriptorDestructureSet = helper("7.13.10")`
  export default function _classApplyDescriptorDestructureSet(receiver, descriptor) {
    if (descriptor.set) {
      if (!("__destrObj" in descriptor)) {
        descriptor.__destrObj = {
          set value(v) {
            descriptor.set.call(receiver, v)
          },
        };
      }
      return descriptor.__destrObj;
    } else {
      if (!descriptor.writable) {
        // This should only throw in strict mode, but class bodies are
        // always strict and private fields can only be used inside
        // class bodies.
        throw new TypeError("attempted to set read only private field");
      }

      return descriptor;
    }
  }
`;
    helpers.classStaticPrivateFieldDestructureSet = helper("7.13.10")`
  import classApplyDescriptorDestructureSet from "classApplyDescriptorDestructureSet";
  import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess";
  import classCheckPrivateStaticFieldDescriptor from "classCheckPrivateStaticFieldDescriptor";
  export default function _classStaticPrivateFieldDestructureSet(receiver, classConstructor, descriptor) {
    classCheckPrivateStaticAccess(receiver, classConstructor);
    classCheckPrivateStaticFieldDescriptor(descriptor, "set");
    return classApplyDescriptorDestructureSet(receiver, descriptor);
  }
`;
    helpers.classCheckPrivateStaticAccess = helper("7.13.10")`
  export default function _classCheckPrivateStaticAccess(receiver, classConstructor) {
    if (receiver !== classConstructor) {
      throw new TypeError("Private static access of wrong provenance");
    }
  }
`;
    helpers.classCheckPrivateStaticFieldDescriptor = helper("7.13.10")`
  export default function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
    if (descriptor === undefined) {
      throw new TypeError("attempted to " + action + " private static field before its declaration");
    }
  }
`;
    helpers.decorate = helper("7.1.5")`
  import toArray from "toArray";
  import toPropertyKey from "toPropertyKey";

  // These comments are stripped by @babel/template
  /*::
  type PropertyDescriptor =
    | {
        value: any,
        writable: boolean,
        configurable: boolean,
        enumerable: boolean,
      }
    | {
        get?: () => any,
        set?: (v: any) => void,
        configurable: boolean,
        enumerable: boolean,
      };

  type FieldDescriptor ={
    writable: boolean,
    configurable: boolean,
    enumerable: boolean,
  };

  type Placement = "static" | "prototype" | "own";
  type Key = string | symbol; // PrivateName is not supported yet.

  type ElementDescriptor =
    | {
        kind: "method",
        key: Key,
        placement: Placement,
        descriptor: PropertyDescriptor
      }
    | {
        kind: "field",
        key: Key,
        placement: Placement,
        descriptor: FieldDescriptor,
        initializer?: () => any,
      };

  // This is exposed to the user code
  type ElementObjectInput = ElementDescriptor & {
    [@@toStringTag]?: "Descriptor"
  };

  // This is exposed to the user code
  type ElementObjectOutput = ElementDescriptor & {
    [@@toStringTag]?: "Descriptor"
    extras?: ElementDescriptor[],
    finisher?: ClassFinisher,
  };

  // This is exposed to the user code
  type ClassObject = {
    [@@toStringTag]?: "Descriptor",
    kind: "class",
    elements: ElementDescriptor[],
  };

  type ElementDecorator = (descriptor: ElementObjectInput) => ?ElementObjectOutput;
  type ClassDecorator = (descriptor: ClassObject) => ?ClassObject;
  type ClassFinisher = <A, B>(cl: Class<A>) => Class<B>;

  // Only used by Babel in the transform output, not part of the spec.
  type ElementDefinition =
    | {
        kind: "method",
        value: any,
        key: Key,
        static?: boolean,
        decorators?: ElementDecorator[],
      }
    | {
        kind: "field",
        value: () => any,
        key: Key,
        static?: boolean,
        decorators?: ElementDecorator[],
    };

  declare function ClassFactory<C>(initialize: (instance: C) => void): {
    F: Class<C>,
    d: ElementDefinition[]
  }

  */

  /*::
  // Various combinations with/without extras and with one or many finishers

  type ElementFinisherExtras = {
    element: ElementDescriptor,
    finisher?: ClassFinisher,
    extras?: ElementDescriptor[],
  };

  type ElementFinishersExtras = {
    element: ElementDescriptor,
    finishers: ClassFinisher[],
    extras: ElementDescriptor[],
  };

  type ElementsFinisher = {
    elements: ElementDescriptor[],
    finisher?: ClassFinisher,
  };

  type ElementsFinishers = {
    elements: ElementDescriptor[],
    finishers: ClassFinisher[],
  };

  */

  /*::

  type Placements = {
    static: Key[],
    prototype: Key[],
    own: Key[],
  };

  */

  // ClassDefinitionEvaluation (Steps 26-*)
  export default function _decorate(
    decorators /*: ClassDecorator[] */,
    factory /*: ClassFactory */,
    superClass /*: ?Class<*> */,
    mixins /*: ?Array<Function> */,
  ) /*: Class<*> */ {
    var api = _getDecoratorsApi();
    if (mixins) {
      for (var i = 0; i < mixins.length; i++) {
        api = mixins[i](api);
      }
    }

    var r = factory(function initialize(O) {
      api.initializeInstanceElements(O, decorated.elements);
    }, superClass);
    var decorated = api.decorateClass(
      _coalesceClassElements(r.d.map(_createElementDescriptor)),
      decorators,
    );

    api.initializeClassElements(r.F, decorated.elements);

    return api.runClassFinishers(r.F, decorated.finishers);
  }

  function _getDecoratorsApi() {
    _getDecoratorsApi = function() {
      return api;
    };

    var api = {
      elementsDefinitionOrder: [["method"], ["field"]],

      // InitializeInstanceElements
      initializeInstanceElements: function(
        /*::<C>*/ O /*: C */,
        elements /*: ElementDescriptor[] */,
      ) {
        ["method", "field"].forEach(function(kind) {
          elements.forEach(function(element /*: ElementDescriptor */) {
            if (element.kind === kind && element.placement === "own") {
              this.defineClassElement(O, element);
            }
          }, this);
        }, this);
      },

      // InitializeClassElements
      initializeClassElements: function(
        /*::<C>*/ F /*: Class<C> */,
        elements /*: ElementDescriptor[] */,
      ) {
        var proto = F.prototype;

        ["method", "field"].forEach(function(kind) {
          elements.forEach(function(element /*: ElementDescriptor */) {
            var placement = element.placement;
            if (
              element.kind === kind &&
              (placement === "static" || placement === "prototype")
            ) {
              var receiver = placement === "static" ? F : proto;
              this.defineClassElement(receiver, element);
            }
          }, this);
        }, this);
      },

      // DefineClassElement
      defineClassElement: function(
        /*::<C>*/ receiver /*: C | Class<C> */,
        element /*: ElementDescriptor */,
      ) {
        var descriptor /*: PropertyDescriptor */ = element.descriptor;
        if (element.kind === "field") {
          var initializer = element.initializer;
          descriptor = {
            enumerable: descriptor.enumerable,
            writable: descriptor.writable,
            configurable: descriptor.configurable,
            value: initializer === void 0 ? void 0 : initializer.call(receiver),
          };
        }
        Object.defineProperty(receiver, element.key, descriptor);
      },

      // DecorateClass
      decorateClass: function(
        elements /*: ElementDescriptor[] */,
        decorators /*: ClassDecorator[] */,
      ) /*: ElementsFinishers */ {
        var newElements /*: ElementDescriptor[] */ = [];
        var finishers /*: ClassFinisher[] */ = [];
        var placements /*: Placements */ = {
          static: [],
          prototype: [],
          own: [],
        };

        elements.forEach(function(element /*: ElementDescriptor */) {
          this.addElementPlacement(element, placements);
        }, this);

        elements.forEach(function(element /*: ElementDescriptor */) {
          if (!_hasDecorators(element)) return newElements.push(element);

          var elementFinishersExtras /*: ElementFinishersExtras */ = this.decorateElement(
            element,
            placements,
          );
          newElements.push(elementFinishersExtras.element);
          newElements.push.apply(newElements, elementFinishersExtras.extras);
          finishers.push.apply(finishers, elementFinishersExtras.finishers);
        }, this);

        if (!decorators) {
          return { elements: newElements, finishers: finishers };
        }

        var result /*: ElementsFinishers */ = this.decorateConstructor(
          newElements,
          decorators,
        );
        finishers.push.apply(finishers, result.finishers);
        result.finishers = finishers;

        return result;
      },

      // AddElementPlacement
      addElementPlacement: function(
        element /*: ElementDescriptor */,
        placements /*: Placements */,
        silent /*: boolean */,
      ) {
        var keys = placements[element.placement];
        if (!silent && keys.indexOf(element.key) !== -1) {
          throw new TypeError("Duplicated element (" + element.key + ")");
        }
        keys.push(element.key);
      },

      // DecorateElement
      decorateElement: function(
        element /*: ElementDescriptor */,
        placements /*: Placements */,
      ) /*: ElementFinishersExtras */ {
        var extras /*: ElementDescriptor[] */ = [];
        var finishers /*: ClassFinisher[] */ = [];

        for (
          var decorators = element.decorators, i = decorators.length - 1;
          i >= 0;
          i--
        ) {
          // (inlined) RemoveElementPlacement
          var keys = placements[element.placement];
          keys.splice(keys.indexOf(element.key), 1);

          var elementObject /*: ElementObjectInput */ = this.fromElementDescriptor(
            element,
          );
          var elementFinisherExtras /*: ElementFinisherExtras */ = this.toElementFinisherExtras(
            (0, decorators[i])(elementObject) /*: ElementObjectOutput */ ||
              elementObject,
          );

          element = elementFinisherExtras.element;
          this.addElementPlacement(element, placements);

          if (elementFinisherExtras.finisher) {
            finishers.push(elementFinisherExtras.finisher);
          }

          var newExtras /*: ElementDescriptor[] | void */ =
            elementFinisherExtras.extras;
          if (newExtras) {
            for (var j = 0; j < newExtras.length; j++) {
              this.addElementPlacement(newExtras[j], placements);
            }
            extras.push.apply(extras, newExtras);
          }
        }

        return { element: element, finishers: finishers, extras: extras };
      },

      // DecorateConstructor
      decorateConstructor: function(
        elements /*: ElementDescriptor[] */,
        decorators /*: ClassDecorator[] */,
      ) /*: ElementsFinishers */ {
        var finishers /*: ClassFinisher[] */ = [];

        for (var i = decorators.length - 1; i >= 0; i--) {
          var obj /*: ClassObject */ = this.fromClassDescriptor(elements);
          var elementsAndFinisher /*: ElementsFinisher */ = this.toClassDescriptor(
            (0, decorators[i])(obj) /*: ClassObject */ || obj,
          );

          if (elementsAndFinisher.finisher !== undefined) {
            finishers.push(elementsAndFinisher.finisher);
          }

          if (elementsAndFinisher.elements !== undefined) {
            elements = elementsAndFinisher.elements;

            for (var j = 0; j < elements.length - 1; j++) {
              for (var k = j + 1; k < elements.length; k++) {
                if (
                  elements[j].key === elements[k].key &&
                  elements[j].placement === elements[k].placement
                ) {
                  throw new TypeError(
                    "Duplicated element (" + elements[j].key + ")",
                  );
                }
              }
            }
          }
        }

        return { elements: elements, finishers: finishers };
      },

      // FromElementDescriptor
      fromElementDescriptor: function(
        element /*: ElementDescriptor */,
      ) /*: ElementObject */ {
        var obj /*: ElementObject */ = {
          kind: element.kind,
          key: element.key,
          placement: element.placement,
          descriptor: element.descriptor,
        };

        var desc = {
          value: "Descriptor",
          configurable: true,
        };
        Object.defineProperty(obj, Symbol.toStringTag, desc);

        if (element.kind === "field") obj.initializer = element.initializer;

        return obj;
      },

      // ToElementDescriptors
      toElementDescriptors: function(
        elementObjects /*: ElementObject[] */,
      ) /*: ElementDescriptor[] */ {
        if (elementObjects === undefined) return;
        return toArray(elementObjects).map(function(elementObject) {
          var element = this.toElementDescriptor(elementObject);
          this.disallowProperty(elementObject, "finisher", "An element descriptor");
          this.disallowProperty(elementObject, "extras", "An element descriptor");
          return element;
        }, this);
      },

      // ToElementDescriptor
      toElementDescriptor: function(
        elementObject /*: ElementObject */,
      ) /*: ElementDescriptor */ {
        var kind = String(elementObject.kind);
        if (kind !== "method" && kind !== "field") {
          throw new TypeError(
            'An element descriptor\\'s .kind property must be either "method" or' +
              ' "field", but a decorator created an element descriptor with' +
              ' .kind "' +
              kind +
              '"',
          );
        }

        var key = toPropertyKey(elementObject.key);

        var placement = String(elementObject.placement);
        if (
          placement !== "static" &&
          placement !== "prototype" &&
          placement !== "own"
        ) {
          throw new TypeError(
            'An element descriptor\\'s .placement property must be one of "static",' +
              ' "prototype" or "own", but a decorator created an element descriptor' +
              ' with .placement "' +
              placement +
              '"',
          );
        }

        var descriptor /*: PropertyDescriptor */ = elementObject.descriptor;

        this.disallowProperty(elementObject, "elements", "An element descriptor");

        var element /*: ElementDescriptor */ = {
          kind: kind,
          key: key,
          placement: placement,
          descriptor: Object.assign({}, descriptor),
        };

        if (kind !== "field") {
          this.disallowProperty(elementObject, "initializer", "A method descriptor");
        } else {
          this.disallowProperty(
            descriptor,
            "get",
            "The property descriptor of a field descriptor",
          );
          this.disallowProperty(
            descriptor,
            "set",
            "The property descriptor of a field descriptor",
          );
          this.disallowProperty(
            descriptor,
            "value",
            "The property descriptor of a field descriptor",
          );

          element.initializer = elementObject.initializer;
        }

        return element;
      },

      toElementFinisherExtras: function(
        elementObject /*: ElementObject */,
      ) /*: ElementFinisherExtras */ {
        var element /*: ElementDescriptor */ = this.toElementDescriptor(
          elementObject,
        );
        var finisher /*: ClassFinisher */ = _optionalCallableProperty(
          elementObject,
          "finisher",
        );
        var extras /*: ElementDescriptors[] */ = this.toElementDescriptors(
          elementObject.extras,
        );

        return { element: element, finisher: finisher, extras: extras };
      },

      // FromClassDescriptor
      fromClassDescriptor: function(
        elements /*: ElementDescriptor[] */,
      ) /*: ClassObject */ {
        var obj = {
          kind: "class",
          elements: elements.map(this.fromElementDescriptor, this),
        };

        var desc = { value: "Descriptor", configurable: true };
        Object.defineProperty(obj, Symbol.toStringTag, desc);

        return obj;
      },

      // ToClassDescriptor
      toClassDescriptor: function(
        obj /*: ClassObject */,
      ) /*: ElementsFinisher */ {
        var kind = String(obj.kind);
        if (kind !== "class") {
          throw new TypeError(
            'A class descriptor\\'s .kind property must be "class", but a decorator' +
              ' created a class descriptor with .kind "' +
              kind +
              '"',
          );
        }

        this.disallowProperty(obj, "key", "A class descriptor");
        this.disallowProperty(obj, "placement", "A class descriptor");
        this.disallowProperty(obj, "descriptor", "A class descriptor");
        this.disallowProperty(obj, "initializer", "A class descriptor");
        this.disallowProperty(obj, "extras", "A class descriptor");

        var finisher = _optionalCallableProperty(obj, "finisher");
        var elements = this.toElementDescriptors(obj.elements);

        return { elements: elements, finisher: finisher };
      },

      // RunClassFinishers
      runClassFinishers: function(
        constructor /*: Class<*> */,
        finishers /*: ClassFinisher[] */,
      ) /*: Class<*> */ {
        for (var i = 0; i < finishers.length; i++) {
          var newConstructor /*: ?Class<*> */ = (0, finishers[i])(constructor);
          if (newConstructor !== undefined) {
            // NOTE: This should check if IsConstructor(newConstructor) is false.
            if (typeof newConstructor !== "function") {
              throw new TypeError("Finishers must return a constructor.");
            }
            constructor = newConstructor;
          }
        }
        return constructor;
      },

      disallowProperty: function(obj, name, objectType) {
        if (obj[name] !== undefined) {
          throw new TypeError(objectType + " can't have a ." + name + " property.");
        }
      }
    };

    return api;
  }

  // ClassElementEvaluation
  function _createElementDescriptor(
    def /*: ElementDefinition */,
  ) /*: ElementDescriptor */ {
    var key = toPropertyKey(def.key);

    var descriptor /*: PropertyDescriptor */;
    if (def.kind === "method") {
      descriptor = {
        value: def.value,
        writable: true,
        configurable: true,
        enumerable: false,
      };
    } else if (def.kind === "get") {
      descriptor = { get: def.value, configurable: true, enumerable: false };
    } else if (def.kind === "set") {
      descriptor = { set: def.value, configurable: true, enumerable: false };
    } else if (def.kind === "field") {
      descriptor = { configurable: true, writable: true, enumerable: true };
    }

    var element /*: ElementDescriptor */ = {
      kind: def.kind === "field" ? "field" : "method",
      key: key,
      placement: def.static
        ? "static"
        : def.kind === "field"
        ? "own"
        : "prototype",
      descriptor: descriptor,
    };
    if (def.decorators) element.decorators = def.decorators;
    if (def.kind === "field") element.initializer = def.value;

    return element;
  }

  // CoalesceGetterSetter
  function _coalesceGetterSetter(
    element /*: ElementDescriptor */,
    other /*: ElementDescriptor */,
  ) {
    if (element.descriptor.get !== undefined) {
      other.descriptor.get = element.descriptor.get;
    } else {
      other.descriptor.set = element.descriptor.set;
    }
  }

  // CoalesceClassElements
  function _coalesceClassElements(
    elements /*: ElementDescriptor[] */,
  ) /*: ElementDescriptor[] */ {
    var newElements /*: ElementDescriptor[] */ = [];

    var isSameElement = function(
      other /*: ElementDescriptor */,
    ) /*: boolean */ {
      return (
        other.kind === "method" &&
        other.key === element.key &&
        other.placement === element.placement
      );
    };

    for (var i = 0; i < elements.length; i++) {
      var element /*: ElementDescriptor */ = elements[i];
      var other /*: ElementDescriptor */;

      if (
        element.kind === "method" &&
        (other = newElements.find(isSameElement))
      ) {
        if (
          _isDataDescriptor(element.descriptor) ||
          _isDataDescriptor(other.descriptor)
        ) {
          if (_hasDecorators(element) || _hasDecorators(other)) {
            throw new ReferenceError(
              "Duplicated methods (" + element.key + ") can't be decorated.",
            );
          }
          other.descriptor = element.descriptor;
        } else {
          if (_hasDecorators(element)) {
            if (_hasDecorators(other)) {
              throw new ReferenceError(
                "Decorators can't be placed on different accessors with for " +
                  "the same property (" +
                  element.key +
                  ").",
              );
            }
            other.decorators = element.decorators;
          }
          _coalesceGetterSetter(element, other);
        }
      } else {
        newElements.push(element);
      }
    }

    return newElements;
  }

  function _hasDecorators(element /*: ElementDescriptor */) /*: boolean */ {
    return element.decorators && element.decorators.length;
  }

  function _isDataDescriptor(desc /*: PropertyDescriptor */) /*: boolean */ {
    return (
      desc !== undefined &&
      !(desc.value === undefined && desc.writable === undefined)
    );
  }

  function _optionalCallableProperty /*::<T>*/(
    obj /*: T */,
    name /*: $Keys<T> */,
  ) /*: ?Function */ {
    var value = obj[name];
    if (value !== undefined && typeof value !== "function") {
      throw new TypeError("Expected '" + name + "' to be a function");
    }
    return value;
  }

`;
    helpers.classPrivateMethodGet = helper("7.1.6")`
  export default function _classPrivateMethodGet(receiver, privateSet, fn) {
    if (!privateSet.has(receiver)) {
      throw new TypeError("attempted to get private field on non-instance");
    }
    return fn;
  }
`;
    helpers.checkPrivateRedeclaration = helper("7.14.1")`
  export default function _checkPrivateRedeclaration(obj, privateCollection) {
    if (privateCollection.has(obj)) {
      throw new TypeError("Cannot initialize the same private elements twice on an object");
    }
  }
`;
    helpers.classPrivateFieldInitSpec = helper("7.14.1")`
  import checkPrivateRedeclaration from "checkPrivateRedeclaration";

  export default function _classPrivateFieldInitSpec(obj, privateMap, value) {
    checkPrivateRedeclaration(obj, privateMap);
    privateMap.set(obj, value);
  }
`;
    helpers.classPrivateMethodInitSpec = helper("7.14.1")`
  import checkPrivateRedeclaration from "checkPrivateRedeclaration";

  export default function _classPrivateMethodInitSpec(obj, privateSet) {
    checkPrivateRedeclaration(obj, privateSet);
    privateSet.add(obj);
  }
`;
    {
      helpers.classPrivateMethodSet = helper("7.1.6")`
    export default function _classPrivateMethodSet() {
      throw new TypeError("attempted to reassign private method");
    }
  `;
    }
    helpers.identity = helper("7.17.0")`
  export default function _identity(x) {
    return x;
  }
`;
  }
});

// node_modules/@babel/helpers/lib/index.js
var require_lib14 = __commonJS({
  "node_modules/@babel/helpers/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    exports.ensure = ensure;
    exports.get = get;
    exports.getDependencies = getDependencies;
    exports.list = void 0;
    exports.minVersion = minVersion;
    var _traverse = require_lib13();
    var _t = require_lib3();
    var _helpers = require_helpers();
    var {
      assignmentExpression,
      cloneNode,
      expressionStatement,
      file,
      identifier
    } = _t;
    function makePath(path) {
      const parts = [];
      for (; path.parentPath; path = path.parentPath) {
        parts.push(path.key);
        if (path.inList)
          parts.push(path.listKey);
      }
      return parts.reverse().join(".");
    }
    var FileClass = void 0;
    function getHelperMetadata(file2) {
      const globals = /* @__PURE__ */ new Set();
      const localBindingNames = /* @__PURE__ */ new Set();
      const dependencies = /* @__PURE__ */ new Map();
      let exportName;
      let exportPath;
      const exportBindingAssignments = [];
      const importPaths = [];
      const importBindingsReferences = [];
      const dependencyVisitor = {
        ImportDeclaration(child) {
          const name2 = child.node.source.value;
          if (!_helpers.default[name2]) {
            throw child.buildCodeFrameError(`Unknown helper ${name2}`);
          }
          if (child.get("specifiers").length !== 1 || !child.get("specifiers.0").isImportDefaultSpecifier()) {
            throw child.buildCodeFrameError("Helpers can only import a default value");
          }
          const bindingIdentifier = child.node.specifiers[0].local;
          dependencies.set(bindingIdentifier, name2);
          importPaths.push(makePath(child));
        },
        ExportDefaultDeclaration(child) {
          const decl = child.get("declaration");
          if (!decl.isFunctionDeclaration() || !decl.node.id) {
            throw decl.buildCodeFrameError("Helpers can only export named function declarations");
          }
          exportName = decl.node.id.name;
          exportPath = makePath(child);
        },
        ExportAllDeclaration(child) {
          throw child.buildCodeFrameError("Helpers can only export default");
        },
        ExportNamedDeclaration(child) {
          throw child.buildCodeFrameError("Helpers can only export default");
        },
        Statement(child) {
          if (child.isImportDeclaration() || child.isExportDeclaration())
            return;
          child.skip();
        }
      };
      const referenceVisitor = {
        Program(path) {
          const bindings = path.scope.getAllBindings();
          Object.keys(bindings).forEach((name2) => {
            if (name2 === exportName)
              return;
            if (dependencies.has(bindings[name2].identifier))
              return;
            localBindingNames.add(name2);
          });
        },
        ReferencedIdentifier(child) {
          const name2 = child.node.name;
          const binding = child.scope.getBinding(name2);
          if (!binding) {
            globals.add(name2);
          } else if (dependencies.has(binding.identifier)) {
            importBindingsReferences.push(makePath(child));
          }
        },
        AssignmentExpression(child) {
          const left = child.get("left");
          if (!(exportName in left.getBindingIdentifiers()))
            return;
          if (!left.isIdentifier()) {
            throw left.buildCodeFrameError("Only simple assignments to exports are allowed in helpers");
          }
          const binding = child.scope.getBinding(exportName);
          if (binding != null && binding.scope.path.isProgram()) {
            exportBindingAssignments.push(makePath(child));
          }
        }
      };
      (0, _traverse.default)(file2.ast, dependencyVisitor, file2.scope);
      (0, _traverse.default)(file2.ast, referenceVisitor, file2.scope);
      if (!exportPath)
        throw new Error("Helpers must have a default export.");
      exportBindingAssignments.reverse();
      return {
        globals: Array.from(globals),
        localBindingNames: Array.from(localBindingNames),
        dependencies,
        exportBindingAssignments,
        exportPath,
        exportName,
        importBindingsReferences,
        importPaths
      };
    }
    function permuteHelperAST(file2, metadata, id, localBindings, getDependency) {
      if (localBindings && !id) {
        throw new Error("Unexpected local bindings for module-based helpers.");
      }
      if (!id)
        return;
      const {
        localBindingNames,
        dependencies,
        exportBindingAssignments,
        exportPath,
        exportName,
        importBindingsReferences,
        importPaths
      } = metadata;
      const dependenciesRefs = {};
      dependencies.forEach((name2, id2) => {
        dependenciesRefs[id2.name] = typeof getDependency === "function" && getDependency(name2) || id2;
      });
      const toRename = {};
      const bindings = new Set(localBindings || []);
      localBindingNames.forEach((name2) => {
        let newName = name2;
        while (bindings.has(newName))
          newName = "_" + newName;
        if (newName !== name2)
          toRename[name2] = newName;
      });
      if (id.type === "Identifier" && exportName !== id.name) {
        toRename[exportName] = id.name;
      }
      const {
        path
      } = file2;
      const exp = path.get(exportPath);
      const imps = importPaths.map((p) => path.get(p));
      const impsBindingRefs = importBindingsReferences.map((p) => path.get(p));
      const decl = exp.get("declaration");
      if (id.type === "Identifier") {
        exp.replaceWith(decl);
      } else if (id.type === "MemberExpression") {
        exportBindingAssignments.forEach((assignPath) => {
          const assign = path.get(assignPath);
          assign.replaceWith(assignmentExpression("=", id, assign.node));
        });
        exp.replaceWith(decl);
        path.pushContainer("body", expressionStatement(assignmentExpression("=", id, identifier(exportName))));
      } else {
        throw new Error("Unexpected helper format.");
      }
      Object.keys(toRename).forEach((name2) => {
        path.scope.rename(name2, toRename[name2]);
      });
      for (const path2 of imps)
        path2.remove();
      for (const path2 of impsBindingRefs) {
        const node2 = cloneNode(dependenciesRefs[path2.node.name]);
        path2.replaceWith(node2);
      }
    }
    var helperData = /* @__PURE__ */ Object.create(null);
    function loadHelper(name2) {
      if (!helperData[name2]) {
        const helper = _helpers.default[name2];
        if (!helper) {
          throw Object.assign(new ReferenceError(`Unknown helper ${name2}`), {
            code: "BABEL_HELPER_UNKNOWN",
            helper: name2
          });
        }
        const fn = () => {
          {
            if (!FileClass) {
              const fakeFile = {
                ast: file(helper.ast()),
                path: null
              };
              (0, _traverse.default)(fakeFile.ast, {
                Program: (path) => (fakeFile.path = path).stop()
              });
              return fakeFile;
            }
          }
          return new FileClass({
            filename: `babel-helper://${name2}`
          }, {
            ast: file(helper.ast()),
            code: "[internal Babel helper code]",
            inputMap: null
          });
        };
        let metadata = null;
        helperData[name2] = {
          minVersion: helper.minVersion,
          build(getDependency, id, localBindings) {
            const file2 = fn();
            metadata || (metadata = getHelperMetadata(file2));
            permuteHelperAST(file2, metadata, id, localBindings, getDependency);
            return {
              nodes: file2.ast.program.body,
              globals: metadata.globals
            };
          },
          getDependencies() {
            metadata || (metadata = getHelperMetadata(fn()));
            return Array.from(metadata.dependencies.values());
          }
        };
      }
      return helperData[name2];
    }
    function get(name2, getDependency, id, localBindings) {
      return loadHelper(name2).build(getDependency, id, localBindings);
    }
    function minVersion(name2) {
      return loadHelper(name2).minVersion;
    }
    function getDependencies(name2) {
      return loadHelper(name2).getDependencies();
    }
    function ensure(name2, newFileClass) {
      FileClass || (FileClass = newFileClass);
      loadHelper(name2);
    }
    var list3 = Object.keys(_helpers.default).map((name2) => name2.replace(/^_/, ""));
    exports.list = list3;
    var _default = get;
    exports.default = _default;
  }
});

// node_modules/@babel/helper-module-imports/lib/import-builder.js
var require_import_builder = __commonJS({
  "node_modules/@babel/helper-module-imports/lib/import-builder.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _assert = require("assert");
    var _t = require_lib3();
    var {
      callExpression,
      cloneNode,
      expressionStatement,
      identifier,
      importDeclaration,
      importDefaultSpecifier,
      importNamespaceSpecifier,
      importSpecifier,
      memberExpression,
      stringLiteral: stringLiteral2,
      variableDeclaration,
      variableDeclarator
    } = _t;
    var ImportBuilder = class {
      constructor(importedSource, scope, hub) {
        this._statements = [];
        this._resultName = null;
        this._importedSource = void 0;
        this._scope = scope;
        this._hub = hub;
        this._importedSource = importedSource;
      }
      done() {
        return {
          statements: this._statements,
          resultName: this._resultName
        };
      }
      import() {
        this._statements.push(importDeclaration([], stringLiteral2(this._importedSource)));
        return this;
      }
      require() {
        this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral2(this._importedSource)])));
        return this;
      }
      namespace(name2 = "namespace") {
        const local = this._scope.generateUidIdentifier(name2);
        const statement = this._statements[this._statements.length - 1];
        _assert(statement.type === "ImportDeclaration");
        _assert(statement.specifiers.length === 0);
        statement.specifiers = [importNamespaceSpecifier(local)];
        this._resultName = cloneNode(local);
        return this;
      }
      default(name2) {
        const id = this._scope.generateUidIdentifier(name2);
        const statement = this._statements[this._statements.length - 1];
        _assert(statement.type === "ImportDeclaration");
        _assert(statement.specifiers.length === 0);
        statement.specifiers = [importDefaultSpecifier(id)];
        this._resultName = cloneNode(id);
        return this;
      }
      named(name2, importName) {
        if (importName === "default")
          return this.default(name2);
        const id = this._scope.generateUidIdentifier(name2);
        const statement = this._statements[this._statements.length - 1];
        _assert(statement.type === "ImportDeclaration");
        _assert(statement.specifiers.length === 0);
        statement.specifiers = [importSpecifier(id, identifier(importName))];
        this._resultName = cloneNode(id);
        return this;
      }
      var(name2) {
        const id = this._scope.generateUidIdentifier(name2);
        let statement = this._statements[this._statements.length - 1];
        if (statement.type !== "ExpressionStatement") {
          _assert(this._resultName);
          statement = expressionStatement(this._resultName);
          this._statements.push(statement);
        }
        this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(id, statement.expression)]);
        this._resultName = cloneNode(id);
        return this;
      }
      defaultInterop() {
        return this._interop(this._hub.addHelper("interopRequireDefault"));
      }
      wildcardInterop() {
        return this._interop(this._hub.addHelper("interopRequireWildcard"));
      }
      _interop(callee) {
        const statement = this._statements[this._statements.length - 1];
        if (statement.type === "ExpressionStatement") {
          statement.expression = callExpression(callee, [statement.expression]);
        } else if (statement.type === "VariableDeclaration") {
          _assert(statement.declarations.length === 1);
          statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]);
        } else {
          _assert.fail("Unexpected type.");
        }
        return this;
      }
      prop(name2) {
        const statement = this._statements[this._statements.length - 1];
        if (statement.type === "ExpressionStatement") {
          statement.expression = memberExpression(statement.expression, identifier(name2));
        } else if (statement.type === "VariableDeclaration") {
          _assert(statement.declarations.length === 1);
          statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name2));
        } else {
          _assert.fail("Unexpected type:" + statement.type);
        }
        return this;
      }
      read(name2) {
        this._resultName = memberExpression(this._resultName, identifier(name2));
      }
    };
    exports.default = ImportBuilder;
  }
});

// node_modules/@babel/helper-module-imports/lib/is-module.js
var require_is_module = __commonJS({
  "node_modules/@babel/helper-module-imports/lib/is-module.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isModule;
    function isModule(path) {
      return path.node.sourceType === "module";
    }
  }
});

// node_modules/@babel/helper-module-imports/lib/import-injector.js
var require_import_injector = __commonJS({
  "node_modules/@babel/helper-module-imports/lib/import-injector.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _assert = require("assert");
    var _t = require_lib3();
    var _importBuilder = require_import_builder();
    var _isModule = require_is_module();
    var {
      numericLiteral,
      sequenceExpression
    } = _t;
    var ImportInjector = class {
      constructor(path, importedSource, opts) {
        this._defaultOpts = {
          importedSource: null,
          importedType: "commonjs",
          importedInterop: "babel",
          importingInterop: "babel",
          ensureLiveReference: false,
          ensureNoContext: false,
          importPosition: "before"
        };
        const programPath = path.find((p) => p.isProgram());
        this._programPath = programPath;
        this._programScope = programPath.scope;
        this._hub = programPath.hub;
        this._defaultOpts = this._applyDefaults(importedSource, opts, true);
      }
      addDefault(importedSourceIn, opts) {
        return this.addNamed("default", importedSourceIn, opts);
      }
      addNamed(importName, importedSourceIn, opts) {
        _assert(typeof importName === "string");
        return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
      }
      addNamespace(importedSourceIn, opts) {
        return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
      }
      addSideEffect(importedSourceIn, opts) {
        return this._generateImport(this._applyDefaults(importedSourceIn, opts), void 0);
      }
      _applyDefaults(importedSource, opts, isInit = false) {
        let newOpts;
        if (typeof importedSource === "string") {
          newOpts = Object.assign({}, this._defaultOpts, {
            importedSource
          }, opts);
        } else {
          _assert(!opts, "Unexpected secondary arguments.");
          newOpts = Object.assign({}, this._defaultOpts, importedSource);
        }
        if (!isInit && opts) {
          if (opts.nameHint !== void 0)
            newOpts.nameHint = opts.nameHint;
          if (opts.blockHoist !== void 0)
            newOpts.blockHoist = opts.blockHoist;
        }
        return newOpts;
      }
      _generateImport(opts, importName) {
        const isDefault = importName === "default";
        const isNamed = !!importName && !isDefault;
        const isNamespace = importName === null;
        const {
          importedSource,
          importedType,
          importedInterop,
          importingInterop,
          ensureLiveReference,
          ensureNoContext,
          nameHint,
          importPosition,
          blockHoist
        } = opts;
        let name2 = nameHint || importName;
        const isMod = (0, _isModule.default)(this._programPath);
        const isModuleForNode = isMod && importingInterop === "node";
        const isModuleForBabel = isMod && importingInterop === "babel";
        if (importPosition === "after" && !isMod) {
          throw new Error(`"importPosition": "after" is only supported in modules`);
        }
        const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
        if (importedType === "es6") {
          if (!isModuleForNode && !isModuleForBabel) {
            throw new Error("Cannot import an ES6 module from CommonJS");
          }
          builder.import();
          if (isNamespace) {
            builder.namespace(nameHint || importedSource);
          } else if (isDefault || isNamed) {
            builder.named(name2, importName);
          }
        } else if (importedType !== "commonjs") {
          throw new Error(`Unexpected interopType "${importedType}"`);
        } else if (importedInterop === "babel") {
          if (isModuleForNode) {
            name2 = name2 !== "default" ? name2 : importedSource;
            const es6Default = `${importedSource}$es6Default`;
            builder.import();
            if (isNamespace) {
              builder.default(es6Default).var(name2 || importedSource).wildcardInterop();
            } else if (isDefault) {
              if (ensureLiveReference) {
                builder.default(es6Default).var(name2 || importedSource).defaultInterop().read("default");
              } else {
                builder.default(es6Default).var(name2).defaultInterop().prop(importName);
              }
            } else if (isNamed) {
              builder.default(es6Default).read(importName);
            }
          } else if (isModuleForBabel) {
            builder.import();
            if (isNamespace) {
              builder.namespace(name2 || importedSource);
            } else if (isDefault || isNamed) {
              builder.named(name2, importName);
            }
          } else {
            builder.require();
            if (isNamespace) {
              builder.var(name2 || importedSource).wildcardInterop();
            } else if ((isDefault || isNamed) && ensureLiveReference) {
              if (isDefault) {
                name2 = name2 !== "default" ? name2 : importedSource;
                builder.var(name2).read(importName);
                builder.defaultInterop();
              } else {
                builder.var(importedSource).read(importName);
              }
            } else if (isDefault) {
              builder.var(name2).defaultInterop().prop(importName);
            } else if (isNamed) {
              builder.var(name2).prop(importName);
            }
          }
        } else if (importedInterop === "compiled") {
          if (isModuleForNode) {
            builder.import();
            if (isNamespace) {
              builder.default(name2 || importedSource);
            } else if (isDefault || isNamed) {
              builder.default(importedSource).read(name2);
            }
          } else if (isModuleForBabel) {
            builder.import();
            if (isNamespace) {
              builder.namespace(name2 || importedSource);
            } else if (isDefault || isNamed) {
              builder.named(name2, importName);
            }
          } else {
            builder.require();
            if (isNamespace) {
              builder.var(name2 || importedSource);
            } else if (isDefault || isNamed) {
              if (ensureLiveReference) {
                builder.var(importedSource).read(name2);
              } else {
                builder.prop(importName).var(name2);
              }
            }
          }
        } else if (importedInterop === "uncompiled") {
          if (isDefault && ensureLiveReference) {
            throw new Error("No live reference for commonjs default");
          }
          if (isModuleForNode) {
            builder.import();
            if (isNamespace) {
              builder.default(name2 || importedSource);
            } else if (isDefault) {
              builder.default(name2);
            } else if (isNamed) {
              builder.default(importedSource).read(name2);
            }
          } else if (isModuleForBabel) {
            builder.import();
            if (isNamespace) {
              builder.default(name2 || importedSource);
            } else if (isDefault) {
              builder.default(name2);
            } else if (isNamed) {
              builder.named(name2, importName);
            }
          } else {
            builder.require();
            if (isNamespace) {
              builder.var(name2 || importedSource);
            } else if (isDefault) {
              builder.var(name2);
            } else if (isNamed) {
              if (ensureLiveReference) {
                builder.var(importedSource).read(name2);
              } else {
                builder.var(name2).prop(importName);
              }
            }
          }
        } else {
          throw new Error(`Unknown importedInterop "${importedInterop}".`);
        }
        const {
          statements,
          resultName
        } = builder.done();
        this._insertStatements(statements, importPosition, blockHoist);
        if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
          return sequenceExpression([numericLiteral(0), resultName]);
        }
        return resultName;
      }
      _insertStatements(statements, importPosition = "before", blockHoist = 3) {
        const body = this._programPath.get("body");
        if (importPosition === "after") {
          for (let i = body.length - 1; i >= 0; i--) {
            if (body[i].isImportDeclaration()) {
              body[i].insertAfter(statements);
              return;
            }
          }
        } else {
          statements.forEach((node2) => {
            node2._blockHoist = blockHoist;
          });
          const targetPath = body.find((p) => {
            const val = p.node._blockHoist;
            return Number.isFinite(val) && val < 4;
          });
          if (targetPath) {
            targetPath.insertBefore(statements);
            return;
          }
        }
        this._programPath.unshiftContainer("body", statements);
      }
    };
    exports.default = ImportInjector;
  }
});

// node_modules/@babel/helper-module-imports/lib/index.js
var require_lib15 = __commonJS({
  "node_modules/@babel/helper-module-imports/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "ImportInjector", {
      enumerable: true,
      get: function() {
        return _importInjector.default;
      }
    });
    exports.addDefault = addDefault;
    exports.addNamed = addNamed;
    exports.addNamespace = addNamespace;
    exports.addSideEffect = addSideEffect;
    Object.defineProperty(exports, "isModule", {
      enumerable: true,
      get: function() {
        return _isModule.default;
      }
    });
    var _importInjector = require_import_injector();
    var _isModule = require_is_module();
    function addDefault(path, importedSource, opts) {
      return new _importInjector.default(path).addDefault(importedSource, opts);
    }
    function addNamed(path, name2, importedSource, opts) {
      return new _importInjector.default(path).addNamed(name2, importedSource, opts);
    }
    function addNamespace(path, importedSource, opts) {
      return new _importInjector.default(path).addNamespace(importedSource, opts);
    }
    function addSideEffect(path, importedSource, opts) {
      return new _importInjector.default(path).addSideEffect(importedSource, opts);
    }
  }
});

// node_modules/@babel/helper-module-transforms/lib/rewrite-this.js
var require_rewrite_this = __commonJS({
  "node_modules/@babel/helper-module-transforms/lib/rewrite-this.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = rewriteThis;
    var _helperEnvironmentVisitor = require_lib6();
    var _traverse = require_lib13();
    var _t = require_lib3();
    var {
      numericLiteral,
      unaryExpression
    } = _t;
    var rewriteThisVisitor = _traverse.default.visitors.merge([_helperEnvironmentVisitor.default, {
      ThisExpression(path) {
        path.replaceWith(unaryExpression("void", numericLiteral(0), true));
      }
    }]);
    function rewriteThis(programPath) {
      (0, _traverse.default)(programPath.node, Object.assign({}, rewriteThisVisitor, {
        noScope: true
      }));
    }
  }
});

// node_modules/@babel/helper-simple-access/lib/index.js
var require_lib16 = __commonJS({
  "node_modules/@babel/helper-simple-access/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = simplifyAccess;
    var _t = require_lib3();
    var {
      LOGICAL_OPERATORS,
      assignmentExpression,
      binaryExpression,
      cloneNode,
      identifier,
      logicalExpression,
      numericLiteral,
      sequenceExpression,
      unaryExpression
    } = _t;
    var simpleAssignmentVisitor = {
      UpdateExpression: {
        exit(path) {
          const {
            scope,
            bindingNames,
            includeUpdateExpression
          } = this;
          if (!includeUpdateExpression) {
            return;
          }
          const arg = path.get("argument");
          if (!arg.isIdentifier())
            return;
          const localName = arg.node.name;
          if (!bindingNames.has(localName))
            return;
          if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
            return;
          }
          if (path.parentPath.isExpressionStatement() && !path.isCompletionRecord()) {
            const operator = path.node.operator == "++" ? "+=" : "-=";
            path.replaceWith(assignmentExpression(operator, arg.node, numericLiteral(1)));
          } else if (path.node.prefix) {
            path.replaceWith(assignmentExpression("=", identifier(localName), binaryExpression(path.node.operator[0], unaryExpression("+", arg.node), numericLiteral(1))));
          } else {
            const old = path.scope.generateUidIdentifierBasedOnNode(arg.node, "old");
            const varName = old.name;
            path.scope.push({
              id: old
            });
            const binary = binaryExpression(
              path.node.operator[0],
              identifier(varName),
              numericLiteral(1)
            );
            path.replaceWith(sequenceExpression([assignmentExpression("=", identifier(varName), unaryExpression("+", arg.node)), assignmentExpression("=", cloneNode(arg.node), binary), identifier(varName)]));
          }
        }
      },
      AssignmentExpression: {
        exit(path) {
          const {
            scope,
            seen,
            bindingNames
          } = this;
          if (path.node.operator === "=")
            return;
          if (seen.has(path.node))
            return;
          seen.add(path.node);
          const left = path.get("left");
          if (!left.isIdentifier())
            return;
          const localName = left.node.name;
          if (!bindingNames.has(localName))
            return;
          if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
            return;
          }
          const operator = path.node.operator.slice(0, -1);
          if (LOGICAL_OPERATORS.includes(operator)) {
            path.replaceWith(logicalExpression(
              operator,
              path.node.left,
              assignmentExpression("=", cloneNode(path.node.left), path.node.right)
            ));
          } else {
            path.node.right = binaryExpression(
              operator,
              cloneNode(path.node.left),
              path.node.right
            );
            path.node.operator = "=";
          }
        }
      }
    };
    function simplifyAccess(path, bindingNames, includeUpdateExpression = true) {
      path.traverse(simpleAssignmentVisitor, {
        scope: path.scope,
        bindingNames,
        seen: /* @__PURE__ */ new WeakSet(),
        includeUpdateExpression
      });
    }
  }
});

// node_modules/@babel/helper-module-transforms/lib/rewrite-live-references.js
var require_rewrite_live_references = __commonJS({
  "node_modules/@babel/helper-module-transforms/lib/rewrite-live-references.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = rewriteLiveReferences;
    var _assert = require("assert");
    var _t = require_lib3();
    var _template = require_lib11();
    var _helperSimpleAccess = require_lib16();
    var {
      assignmentExpression,
      callExpression,
      cloneNode,
      expressionStatement,
      getOuterBindingIdentifiers,
      identifier,
      isMemberExpression: isMemberExpression2,
      isVariableDeclaration: isVariableDeclaration2,
      jsxIdentifier: jsxIdentifier2,
      jsxMemberExpression,
      memberExpression,
      numericLiteral,
      sequenceExpression,
      stringLiteral: stringLiteral2,
      variableDeclaration,
      variableDeclarator
    } = _t;
    function isInType(path) {
      do {
        switch (path.parent.type) {
          case "TSTypeAnnotation":
          case "TSTypeAliasDeclaration":
          case "TSTypeReference":
          case "TypeAnnotation":
          case "TypeAlias":
            return true;
          case "ExportSpecifier":
            return path.parentPath.parent.exportKind === "type";
          default:
            if (path.parentPath.isStatement() || path.parentPath.isExpression()) {
              return false;
            }
        }
      } while (path = path.parentPath);
    }
    function rewriteLiveReferences(programPath, metadata) {
      const imported = /* @__PURE__ */ new Map();
      const exported = /* @__PURE__ */ new Map();
      const requeueInParent = (path) => {
        programPath.requeue(path);
      };
      for (const [source2, data3] of metadata.source) {
        for (const [localName, importName] of data3.imports) {
          imported.set(localName, [source2, importName, null]);
        }
        for (const localName of data3.importsNamespace) {
          imported.set(localName, [source2, null, localName]);
        }
      }
      for (const [local, data3] of metadata.local) {
        let exportMeta = exported.get(local);
        if (!exportMeta) {
          exportMeta = [];
          exported.set(local, exportMeta);
        }
        exportMeta.push(...data3.names);
      }
      const rewriteBindingInitVisitorState = {
        metadata,
        requeueInParent,
        scope: programPath.scope,
        exported
      };
      programPath.traverse(rewriteBindingInitVisitor, rewriteBindingInitVisitorState);
      (0, _helperSimpleAccess.default)(programPath, /* @__PURE__ */ new Set([...Array.from(imported.keys()), ...Array.from(exported.keys())]), false);
      const rewriteReferencesVisitorState = {
        seen: /* @__PURE__ */ new WeakSet(),
        metadata,
        requeueInParent,
        scope: programPath.scope,
        imported,
        exported,
        buildImportReference: ([source2, importName, localName], identNode) => {
          const meta = metadata.source.get(source2);
          meta.referenced = true;
          if (localName) {
            if (meta.lazy) {
              identNode = callExpression(identNode, []);
            }
            return identNode;
          }
          let namespace = identifier(meta.name);
          if (meta.lazy)
            namespace = callExpression(namespace, []);
          if (importName === "default" && meta.interop === "node-default") {
            return namespace;
          }
          const computed = metadata.stringSpecifiers.has(importName);
          return memberExpression(namespace, computed ? stringLiteral2(importName) : identifier(importName), computed);
        }
      };
      programPath.traverse(rewriteReferencesVisitor, rewriteReferencesVisitorState);
    }
    var rewriteBindingInitVisitor = {
      Scope(path) {
        path.skip();
      },
      ClassDeclaration(path) {
        const {
          requeueInParent,
          exported,
          metadata
        } = this;
        const {
          id
        } = path.node;
        if (!id)
          throw new Error("Expected class to have a name");
        const localName = id.name;
        const exportNames = exported.get(localName) || [];
        if (exportNames.length > 0) {
          const statement = expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, identifier(localName), path.scope));
          statement._blockHoist = path.node._blockHoist;
          requeueInParent(path.insertAfter(statement)[0]);
        }
      },
      VariableDeclaration(path) {
        const {
          requeueInParent,
          exported,
          metadata
        } = this;
        Object.keys(path.getOuterBindingIdentifiers()).forEach((localName) => {
          const exportNames = exported.get(localName) || [];
          if (exportNames.length > 0) {
            const statement = expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, identifier(localName), path.scope));
            statement._blockHoist = path.node._blockHoist;
            requeueInParent(path.insertAfter(statement)[0]);
          }
        });
      }
    };
    var buildBindingExportAssignmentExpression = (metadata, exportNames, localExpr, scope) => {
      const exportsObjectName = metadata.exportName;
      for (let currentScope = scope; currentScope != null; currentScope = currentScope.parent) {
        if (currentScope.hasOwnBinding(exportsObjectName)) {
          currentScope.rename(exportsObjectName);
        }
      }
      return (exportNames || []).reduce((expr, exportName) => {
        const {
          stringSpecifiers
        } = metadata;
        const computed = stringSpecifiers.has(exportName);
        return assignmentExpression("=", memberExpression(identifier(exportsObjectName), computed ? stringLiteral2(exportName) : identifier(exportName), computed), expr);
      }, localExpr);
    };
    var buildImportThrow = (localName) => {
      return _template.default.expression.ast`
    (function() {
      throw new Error('"' + '${localName}' + '" is read-only.');
    })()
  `;
    };
    var rewriteReferencesVisitor = {
      ReferencedIdentifier(path) {
        const {
          seen,
          buildImportReference,
          scope,
          imported,
          requeueInParent
        } = this;
        if (seen.has(path.node))
          return;
        seen.add(path.node);
        const localName = path.node.name;
        const importData = imported.get(localName);
        if (importData) {
          if (isInType(path)) {
            throw path.buildCodeFrameError(`Cannot transform the imported binding "${localName}" since it's also used in a type annotation. Please strip type annotations using @babel/preset-typescript or @babel/preset-flow.`);
          }
          const localBinding = path.scope.getBinding(localName);
          const rootBinding = scope.getBinding(localName);
          if (rootBinding !== localBinding)
            return;
          const ref3 = buildImportReference(importData, path.node);
          ref3.loc = path.node.loc;
          if ((path.parentPath.isCallExpression({
            callee: path.node
          }) || path.parentPath.isOptionalCallExpression({
            callee: path.node
          }) || path.parentPath.isTaggedTemplateExpression({
            tag: path.node
          })) && isMemberExpression2(ref3)) {
            path.replaceWith(sequenceExpression([numericLiteral(0), ref3]));
          } else if (path.isJSXIdentifier() && isMemberExpression2(ref3)) {
            const {
              object,
              property
            } = ref3;
            path.replaceWith(jsxMemberExpression(jsxIdentifier2(object.name), jsxIdentifier2(property.name)));
          } else {
            path.replaceWith(ref3);
          }
          requeueInParent(path);
          path.skip();
        }
      },
      UpdateExpression(path) {
        const {
          scope,
          seen,
          imported,
          exported,
          requeueInParent,
          buildImportReference
        } = this;
        if (seen.has(path.node))
          return;
        seen.add(path.node);
        const arg = path.get("argument");
        if (arg.isMemberExpression())
          return;
        const update = path.node;
        if (arg.isIdentifier()) {
          const localName = arg.node.name;
          if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
            return;
          }
          const exportedNames = exported.get(localName);
          const importData = imported.get(localName);
          if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) {
            if (importData) {
              path.replaceWith(assignmentExpression(update.operator[0] + "=", buildImportReference(importData, arg.node), buildImportThrow(localName)));
            } else if (update.prefix) {
              path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, cloneNode(update), path.scope));
            } else {
              const ref3 = scope.generateDeclaredUidIdentifier(localName);
              path.replaceWith(sequenceExpression([assignmentExpression("=", cloneNode(ref3), cloneNode(update)), buildBindingExportAssignmentExpression(this.metadata, exportedNames, identifier(localName), path.scope), cloneNode(ref3)]));
            }
          }
        }
        requeueInParent(path);
        path.skip();
      },
      AssignmentExpression: {
        exit(path) {
          const {
            scope,
            seen,
            imported,
            exported,
            requeueInParent,
            buildImportReference
          } = this;
          if (seen.has(path.node))
            return;
          seen.add(path.node);
          const left = path.get("left");
          if (left.isMemberExpression())
            return;
          if (left.isIdentifier()) {
            const localName = left.node.name;
            if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
              return;
            }
            const exportedNames = exported.get(localName);
            const importData = imported.get(localName);
            if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) {
              _assert(path.node.operator === "=", "Path was not simplified");
              const assignment = path.node;
              if (importData) {
                assignment.left = buildImportReference(importData, left.node);
                assignment.right = sequenceExpression([assignment.right, buildImportThrow(localName)]);
              }
              path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, assignment, path.scope));
              requeueInParent(path);
            }
          } else {
            const ids = left.getOuterBindingIdentifiers();
            const programScopeIds = Object.keys(ids).filter((localName) => scope.getBinding(localName) === path.scope.getBinding(localName));
            const id = programScopeIds.find((localName) => imported.has(localName));
            if (id) {
              path.node.right = sequenceExpression([path.node.right, buildImportThrow(id)]);
            }
            const items = [];
            programScopeIds.forEach((localName) => {
              const exportedNames = exported.get(localName) || [];
              if (exportedNames.length > 0) {
                items.push(buildBindingExportAssignmentExpression(this.metadata, exportedNames, identifier(localName), path.scope));
              }
            });
            if (items.length > 0) {
              let node2 = sequenceExpression(items);
              if (path.parentPath.isExpressionStatement()) {
                node2 = expressionStatement(node2);
                node2._blockHoist = path.parentPath.node._blockHoist;
              }
              const statement = path.insertAfter(node2)[0];
              requeueInParent(statement);
            }
          }
        }
      },
      "ForOfStatement|ForInStatement"(path) {
        const {
          scope,
          node: node2
        } = path;
        const {
          left
        } = node2;
        const {
          exported,
          imported,
          scope: programScope
        } = this;
        if (!isVariableDeclaration2(left)) {
          let didTransformExport = false, importConstViolationName;
          const loopBodyScope = path.get("body").scope;
          for (const name2 of Object.keys(getOuterBindingIdentifiers(left))) {
            if (programScope.getBinding(name2) === scope.getBinding(name2)) {
              if (exported.has(name2)) {
                didTransformExport = true;
                if (loopBodyScope.hasOwnBinding(name2)) {
                  loopBodyScope.rename(name2);
                }
              }
              if (imported.has(name2) && !importConstViolationName) {
                importConstViolationName = name2;
              }
            }
          }
          if (!didTransformExport && !importConstViolationName) {
            return;
          }
          path.ensureBlock();
          const bodyPath = path.get("body");
          const newLoopId = scope.generateUidIdentifierBasedOnNode(left);
          path.get("left").replaceWith(variableDeclaration("let", [variableDeclarator(cloneNode(newLoopId))]));
          scope.registerDeclaration(path.get("left"));
          if (didTransformExport) {
            bodyPath.unshiftContainer("body", expressionStatement(assignmentExpression("=", left, newLoopId)));
          }
          if (importConstViolationName) {
            bodyPath.unshiftContainer("body", expressionStatement(buildImportThrow(importConstViolationName)));
          }
        }
      }
    };
  }
});

// node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js
var require_normalize_and_load_metadata = __commonJS({
  "node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = normalizeModuleAndLoadMetadata;
    exports.hasExports = hasExports;
    exports.isSideEffectImport = isSideEffectImport;
    exports.validateImportInteropOption = validateImportInteropOption;
    var _path = require("path");
    var _helperValidatorIdentifier = require_lib();
    var _helperSplitExportDeclaration = require_lib5();
    function hasExports(metadata) {
      return metadata.hasExports;
    }
    function isSideEffectImport(source2) {
      return source2.imports.size === 0 && source2.importsNamespace.size === 0 && source2.reexports.size === 0 && source2.reexportNamespace.size === 0 && !source2.reexportAll;
    }
    function validateImportInteropOption(importInterop) {
      if (typeof importInterop !== "function" && importInterop !== "none" && importInterop !== "babel" && importInterop !== "node") {
        throw new Error(`.importInterop must be one of "none", "babel", "node", or a function returning one of those values (received ${importInterop}).`);
      }
      return importInterop;
    }
    function resolveImportInterop(importInterop, source2, filename) {
      if (typeof importInterop === "function") {
        return validateImportInteropOption(importInterop(source2, filename));
      }
      return importInterop;
    }
    function normalizeModuleAndLoadMetadata(programPath, exportName, {
      importInterop,
      initializeReexports = false,
      lazy = false,
      esNamespaceOnly = false,
      filename
    }) {
      if (!exportName) {
        exportName = programPath.scope.generateUidIdentifier("exports").name;
      }
      const stringSpecifiers = /* @__PURE__ */ new Set();
      nameAnonymousExports(programPath);
      const {
        local,
        sources,
        hasExports: hasExports2
      } = getModuleMetadata(programPath, {
        initializeReexports,
        lazy
      }, stringSpecifiers);
      removeImportExportDeclarations(programPath);
      for (const [source2, metadata] of sources) {
        if (metadata.importsNamespace.size > 0) {
          metadata.name = metadata.importsNamespace.values().next().value;
        }
        const resolvedInterop = resolveImportInterop(importInterop, source2, filename);
        if (resolvedInterop === "none") {
          metadata.interop = "none";
        } else if (resolvedInterop === "node" && metadata.interop === "namespace") {
          metadata.interop = "node-namespace";
        } else if (resolvedInterop === "node" && metadata.interop === "default") {
          metadata.interop = "node-default";
        } else if (esNamespaceOnly && metadata.interop === "namespace") {
          metadata.interop = "default";
        }
      }
      return {
        exportName,
        exportNameListName: null,
        hasExports: hasExports2,
        local,
        source: sources,
        stringSpecifiers
      };
    }
    function getExportSpecifierName(path, stringSpecifiers) {
      if (path.isIdentifier()) {
        return path.node.name;
      } else if (path.isStringLiteral()) {
        const stringValue = path.node.value;
        if (!(0, _helperValidatorIdentifier.isIdentifierName)(stringValue)) {
          stringSpecifiers.add(stringValue);
        }
        return stringValue;
      } else {
        throw new Error(`Expected export specifier to be either Identifier or StringLiteral, got ${path.node.type}`);
      }
    }
    function assertExportSpecifier(path) {
      if (path.isExportSpecifier()) {
        return;
      } else if (path.isExportNamespaceSpecifier()) {
        throw path.buildCodeFrameError("Export namespace should be first transformed by `@babel/plugin-proposal-export-namespace-from`.");
      } else {
        throw path.buildCodeFrameError("Unexpected export specifier type");
      }
    }
    function getModuleMetadata(programPath, {
      lazy,
      initializeReexports
    }, stringSpecifiers) {
      const localData = getLocalExportMetadata(programPath, initializeReexports, stringSpecifiers);
      const sourceData = /* @__PURE__ */ new Map();
      const getData = (sourceNode) => {
        const source2 = sourceNode.value;
        let data3 = sourceData.get(source2);
        if (!data3) {
          data3 = {
            name: programPath.scope.generateUidIdentifier((0, _path.basename)(source2, (0, _path.extname)(source2))).name,
            interop: "none",
            loc: null,
            imports: /* @__PURE__ */ new Map(),
            importsNamespace: /* @__PURE__ */ new Set(),
            reexports: /* @__PURE__ */ new Map(),
            reexportNamespace: /* @__PURE__ */ new Set(),
            reexportAll: null,
            lazy: false,
            referenced: false
          };
          sourceData.set(source2, data3);
        }
        return data3;
      };
      let hasExports2 = false;
      programPath.get("body").forEach((child) => {
        if (child.isImportDeclaration()) {
          const data3 = getData(child.node.source);
          if (!data3.loc)
            data3.loc = child.node.loc;
          child.get("specifiers").forEach((spec) => {
            if (spec.isImportDefaultSpecifier()) {
              const localName = spec.get("local").node.name;
              data3.imports.set(localName, "default");
              const reexport = localData.get(localName);
              if (reexport) {
                localData.delete(localName);
                reexport.names.forEach((name2) => {
                  data3.reexports.set(name2, "default");
                });
                data3.referenced = true;
              }
            } else if (spec.isImportNamespaceSpecifier()) {
              const localName = spec.get("local").node.name;
              data3.importsNamespace.add(localName);
              const reexport = localData.get(localName);
              if (reexport) {
                localData.delete(localName);
                reexport.names.forEach((name2) => {
                  data3.reexportNamespace.add(name2);
                });
                data3.referenced = true;
              }
            } else if (spec.isImportSpecifier()) {
              const importName = getExportSpecifierName(spec.get("imported"), stringSpecifiers);
              const localName = spec.get("local").node.name;
              data3.imports.set(localName, importName);
              const reexport = localData.get(localName);
              if (reexport) {
                localData.delete(localName);
                reexport.names.forEach((name2) => {
                  data3.reexports.set(name2, importName);
                });
                data3.referenced = true;
              }
            }
          });
        } else if (child.isExportAllDeclaration()) {
          hasExports2 = true;
          const data3 = getData(child.node.source);
          if (!data3.loc)
            data3.loc = child.node.loc;
          data3.reexportAll = {
            loc: child.node.loc
          };
          data3.referenced = true;
        } else if (child.isExportNamedDeclaration() && child.node.source) {
          hasExports2 = true;
          const data3 = getData(child.node.source);
          if (!data3.loc)
            data3.loc = child.node.loc;
          child.get("specifiers").forEach((spec) => {
            assertExportSpecifier(spec);
            const importName = getExportSpecifierName(spec.get("local"), stringSpecifiers);
            const exportName = getExportSpecifierName(spec.get("exported"), stringSpecifiers);
            data3.reexports.set(exportName, importName);
            data3.referenced = true;
            if (exportName === "__esModule") {
              throw spec.get("exported").buildCodeFrameError('Illegal export "__esModule".');
            }
          });
        } else if (child.isExportNamedDeclaration() || child.isExportDefaultDeclaration()) {
          hasExports2 = true;
        }
      });
      for (const metadata of sourceData.values()) {
        let needsDefault = false;
        let needsNamed = false;
        if (metadata.importsNamespace.size > 0) {
          needsDefault = true;
          needsNamed = true;
        }
        if (metadata.reexportAll) {
          needsNamed = true;
        }
        for (const importName of metadata.imports.values()) {
          if (importName === "default")
            needsDefault = true;
          else
            needsNamed = true;
        }
        for (const importName of metadata.reexports.values()) {
          if (importName === "default")
            needsDefault = true;
          else
            needsNamed = true;
        }
        if (needsDefault && needsNamed) {
          metadata.interop = "namespace";
        } else if (needsDefault) {
          metadata.interop = "default";
        }
      }
      for (const [source2, metadata] of sourceData) {
        if (lazy !== false && !(isSideEffectImport(metadata) || metadata.reexportAll)) {
          if (lazy === true) {
            metadata.lazy = !/\./.test(source2);
          } else if (Array.isArray(lazy)) {
            metadata.lazy = lazy.indexOf(source2) !== -1;
          } else if (typeof lazy === "function") {
            metadata.lazy = lazy(source2);
          } else {
            throw new Error(`.lazy must be a boolean, string array, or function`);
          }
        }
      }
      return {
        hasExports: hasExports2,
        local: localData,
        sources: sourceData
      };
    }
    function getLocalExportMetadata(programPath, initializeReexports, stringSpecifiers) {
      const bindingKindLookup = /* @__PURE__ */ new Map();
      programPath.get("body").forEach((child) => {
        let kind;
        if (child.isImportDeclaration()) {
          kind = "import";
        } else {
          if (child.isExportDefaultDeclaration()) {
            child = child.get("declaration");
          }
          if (child.isExportNamedDeclaration()) {
            if (child.node.declaration) {
              child = child.get("declaration");
            } else if (initializeReexports && child.node.source && child.get("source").isStringLiteral()) {
              child.get("specifiers").forEach((spec) => {
                assertExportSpecifier(spec);
                bindingKindLookup.set(spec.get("local").node.name, "block");
              });
              return;
            }
          }
          if (child.isFunctionDeclaration()) {
            kind = "hoisted";
          } else if (child.isClassDeclaration()) {
            kind = "block";
          } else if (child.isVariableDeclaration({
            kind: "var"
          })) {
            kind = "var";
          } else if (child.isVariableDeclaration()) {
            kind = "block";
          } else {
            return;
          }
        }
        Object.keys(child.getOuterBindingIdentifiers()).forEach((name2) => {
          bindingKindLookup.set(name2, kind);
        });
      });
      const localMetadata = /* @__PURE__ */ new Map();
      const getLocalMetadata = (idPath) => {
        const localName = idPath.node.name;
        let metadata = localMetadata.get(localName);
        if (!metadata) {
          const kind = bindingKindLookup.get(localName);
          if (kind === void 0) {
            throw idPath.buildCodeFrameError(`Exporting local "${localName}", which is not declared.`);
          }
          metadata = {
            names: [],
            kind
          };
          localMetadata.set(localName, metadata);
        }
        return metadata;
      };
      programPath.get("body").forEach((child) => {
        if (child.isExportNamedDeclaration() && (initializeReexports || !child.node.source)) {
          if (child.node.declaration) {
            const declaration = child.get("declaration");
            const ids = declaration.getOuterBindingIdentifierPaths();
            Object.keys(ids).forEach((name2) => {
              if (name2 === "__esModule") {
                throw declaration.buildCodeFrameError('Illegal export "__esModule".');
              }
              getLocalMetadata(ids[name2]).names.push(name2);
            });
          } else {
            child.get("specifiers").forEach((spec) => {
              const local = spec.get("local");
              const exported = spec.get("exported");
              const localMetadata2 = getLocalMetadata(local);
              const exportName = getExportSpecifierName(exported, stringSpecifiers);
              if (exportName === "__esModule") {
                throw exported.buildCodeFrameError('Illegal export "__esModule".');
              }
              localMetadata2.names.push(exportName);
            });
          }
        } else if (child.isExportDefaultDeclaration()) {
          const declaration = child.get("declaration");
          if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) {
            getLocalMetadata(declaration.get("id")).names.push("default");
          } else {
            throw declaration.buildCodeFrameError("Unexpected default expression export.");
          }
        }
      });
      return localMetadata;
    }
    function nameAnonymousExports(programPath) {
      programPath.get("body").forEach((child) => {
        if (!child.isExportDefaultDeclaration())
          return;
        (0, _helperSplitExportDeclaration.default)(child);
      });
    }
    function removeImportExportDeclarations(programPath) {
      programPath.get("body").forEach((child) => {
        if (child.isImportDeclaration()) {
          child.remove();
        } else if (child.isExportNamedDeclaration()) {
          if (child.node.declaration) {
            child.node.declaration._blockHoist = child.node._blockHoist;
            child.replaceWith(child.node.declaration);
          } else {
            child.remove();
          }
        } else if (child.isExportDefaultDeclaration()) {
          const declaration = child.get("declaration");
          if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) {
            declaration._blockHoist = child.node._blockHoist;
            child.replaceWith(declaration);
          } else {
            throw declaration.buildCodeFrameError("Unexpected default expression export.");
          }
        } else if (child.isExportAllDeclaration()) {
          child.remove();
        }
      });
    }
  }
});

// node_modules/@babel/helper-module-transforms/lib/dynamic-import.js
var require_dynamic_import = __commonJS({
  "node_modules/@babel/helper-module-transforms/lib/dynamic-import.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.buildDynamicImport = buildDynamicImport;
    exports.getDynamicImportSource = getDynamicImportSource;
    var t3 = require_lib3();
    var _template = require_lib11();
    function getDynamicImportSource(node2) {
      const [source2] = node2.arguments;
      return t3.isStringLiteral(source2) || t3.isTemplateLiteral(source2) ? source2 : _template.default.expression.ast`\`\${${source2}}\``;
    }
    function buildDynamicImport(node2, deferToThen, wrapWithPromise, builder) {
      const [specifier] = node2.arguments;
      if (t3.isStringLiteral(specifier) || t3.isTemplateLiteral(specifier) && specifier.quasis.length === 0) {
        if (deferToThen) {
          return _template.default.expression.ast`
        Promise.resolve().then(() => ${builder(specifier)})
      `;
        } else
          return builder(specifier);
      }
      const specifierToString = t3.isTemplateLiteral(specifier) ? t3.identifier("specifier") : t3.templateLiteral([t3.templateElement({
        raw: ""
      }), t3.templateElement({
        raw: ""
      })], [t3.identifier("specifier")]);
      if (deferToThen) {
        return _template.default.expression.ast`
      (specifier =>
        new Promise(r => r(${specifierToString}))
          .then(s => ${builder(t3.identifier("s"))})
      )(${specifier})
    `;
      } else if (wrapWithPromise) {
        return _template.default.expression.ast`
      (specifier =>
        new Promise(r => r(${builder(specifierToString)}))
      )(${specifier})
    `;
      } else {
        return _template.default.expression.ast`
      (specifier => ${builder(specifierToString)})(${specifier})
    `;
      }
    }
  }
});

// node_modules/@babel/helper-module-transforms/lib/get-module-name.js
var require_get_module_name = __commonJS({
  "node_modules/@babel/helper-module-transforms/lib/get-module-name.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = getModuleName;
    {
      const originalGetModuleName = getModuleName;
      exports.default = getModuleName = function getModuleName2(rootOpts, pluginOpts) {
        var _pluginOpts$moduleId, _pluginOpts$moduleIds, _pluginOpts$getModule, _pluginOpts$moduleRoo;
        return originalGetModuleName(rootOpts, {
          moduleId: (_pluginOpts$moduleId = pluginOpts.moduleId) != null ? _pluginOpts$moduleId : rootOpts.moduleId,
          moduleIds: (_pluginOpts$moduleIds = pluginOpts.moduleIds) != null ? _pluginOpts$moduleIds : rootOpts.moduleIds,
          getModuleId: (_pluginOpts$getModule = pluginOpts.getModuleId) != null ? _pluginOpts$getModule : rootOpts.getModuleId,
          moduleRoot: (_pluginOpts$moduleRoo = pluginOpts.moduleRoot) != null ? _pluginOpts$moduleRoo : rootOpts.moduleRoot
        });
      };
    }
    function getModuleName(rootOpts, pluginOpts) {
      const {
        filename,
        filenameRelative = filename,
        sourceRoot = pluginOpts.moduleRoot
      } = rootOpts;
      const {
        moduleId,
        moduleIds = !!moduleId,
        getModuleId,
        moduleRoot = sourceRoot
      } = pluginOpts;
      if (!moduleIds)
        return null;
      if (moduleId != null && !getModuleId) {
        return moduleId;
      }
      let moduleName = moduleRoot != null ? moduleRoot + "/" : "";
      if (filenameRelative) {
        const sourceRootReplacer = sourceRoot != null ? new RegExp("^" + sourceRoot + "/?") : "";
        moduleName += filenameRelative.replace(sourceRootReplacer, "").replace(/\.(\w*?)$/, "");
      }
      moduleName = moduleName.replace(/\\/g, "/");
      if (getModuleId) {
        return getModuleId(moduleName) || moduleName;
      } else {
        return moduleName;
      }
    }
  }
});

// node_modules/@babel/helper-module-transforms/lib/index.js
var require_lib17 = __commonJS({
  "node_modules/@babel/helper-module-transforms/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "buildDynamicImport", {
      enumerable: true,
      get: function() {
        return _dynamicImport.buildDynamicImport;
      }
    });
    exports.buildNamespaceInitStatements = buildNamespaceInitStatements;
    exports.ensureStatementsHoisted = ensureStatementsHoisted;
    Object.defineProperty(exports, "getDynamicImportSource", {
      enumerable: true,
      get: function() {
        return _dynamicImport.getDynamicImportSource;
      }
    });
    Object.defineProperty(exports, "getModuleName", {
      enumerable: true,
      get: function() {
        return _getModuleName.default;
      }
    });
    Object.defineProperty(exports, "hasExports", {
      enumerable: true,
      get: function() {
        return _normalizeAndLoadMetadata.hasExports;
      }
    });
    Object.defineProperty(exports, "isModule", {
      enumerable: true,
      get: function() {
        return _helperModuleImports.isModule;
      }
    });
    Object.defineProperty(exports, "isSideEffectImport", {
      enumerable: true,
      get: function() {
        return _normalizeAndLoadMetadata.isSideEffectImport;
      }
    });
    exports.rewriteModuleStatementsAndPrepareHeader = rewriteModuleStatementsAndPrepareHeader;
    Object.defineProperty(exports, "rewriteThis", {
      enumerable: true,
      get: function() {
        return _rewriteThis.default;
      }
    });
    exports.wrapInterop = wrapInterop;
    var _assert = require("assert");
    var _t = require_lib3();
    var _template = require_lib11();
    var _helperModuleImports = require_lib15();
    var _rewriteThis = require_rewrite_this();
    var _rewriteLiveReferences = require_rewrite_live_references();
    var _normalizeAndLoadMetadata = require_normalize_and_load_metadata();
    var _dynamicImport = require_dynamic_import();
    var _getModuleName = require_get_module_name();
    var {
      booleanLiteral,
      callExpression,
      cloneNode,
      directive,
      directiveLiteral,
      expressionStatement,
      identifier,
      isIdentifier: isIdentifier3,
      memberExpression,
      stringLiteral: stringLiteral2,
      valueToNode,
      variableDeclaration,
      variableDeclarator
    } = _t;
    function rewriteModuleStatementsAndPrepareHeader(path, {
      loose,
      exportName,
      strict,
      allowTopLevelThis,
      strictMode,
      noInterop,
      importInterop = noInterop ? "none" : "babel",
      lazy,
      esNamespaceOnly,
      filename,
      constantReexports = loose,
      enumerableModuleMeta = loose,
      noIncompleteNsImportDetection
    }) {
      (0, _normalizeAndLoadMetadata.validateImportInteropOption)(importInterop);
      _assert((0, _helperModuleImports.isModule)(path), "Cannot process module statements in a script");
      path.node.sourceType = "script";
      const meta = (0, _normalizeAndLoadMetadata.default)(path, exportName, {
        importInterop,
        initializeReexports: constantReexports,
        lazy,
        esNamespaceOnly,
        filename
      });
      if (!allowTopLevelThis) {
        (0, _rewriteThis.default)(path);
      }
      (0, _rewriteLiveReferences.default)(path, meta);
      if (strictMode !== false) {
        const hasStrict = path.node.directives.some((directive2) => {
          return directive2.value.value === "use strict";
        });
        if (!hasStrict) {
          path.unshiftContainer("directives", directive(directiveLiteral("use strict")));
        }
      }
      const headers = [];
      if ((0, _normalizeAndLoadMetadata.hasExports)(meta) && !strict) {
        headers.push(buildESModuleHeader(meta, enumerableModuleMeta));
      }
      const nameList = buildExportNameListDeclaration(path, meta);
      if (nameList) {
        meta.exportNameListName = nameList.name;
        headers.push(nameList.statement);
      }
      headers.push(...buildExportInitializationStatements(path, meta, constantReexports, noIncompleteNsImportDetection));
      return {
        meta,
        headers
      };
    }
    function ensureStatementsHoisted(statements) {
      statements.forEach((header) => {
        header._blockHoist = 3;
      });
    }
    function wrapInterop(programPath, expr, type) {
      if (type === "none") {
        return null;
      }
      if (type === "node-namespace") {
        return callExpression(programPath.hub.addHelper("interopRequireWildcard"), [expr, booleanLiteral(true)]);
      } else if (type === "node-default") {
        return null;
      }
      let helper;
      if (type === "default") {
        helper = "interopRequireDefault";
      } else if (type === "namespace") {
        helper = "interopRequireWildcard";
      } else {
        throw new Error(`Unknown interop: ${type}`);
      }
      return callExpression(programPath.hub.addHelper(helper), [expr]);
    }
    function buildNamespaceInitStatements(metadata, sourceMetadata, constantReexports = false) {
      const statements = [];
      let srcNamespace = identifier(sourceMetadata.name);
      if (sourceMetadata.lazy)
        srcNamespace = callExpression(srcNamespace, []);
      for (const localName of sourceMetadata.importsNamespace) {
        if (localName === sourceMetadata.name)
          continue;
        statements.push(_template.default.statement`var NAME = SOURCE;`({
          NAME: localName,
          SOURCE: cloneNode(srcNamespace)
        }));
      }
      if (constantReexports) {
        statements.push(...buildReexportsFromMeta(metadata, sourceMetadata, true));
      }
      for (const exportName of sourceMetadata.reexportNamespace) {
        statements.push((sourceMetadata.lazy ? _template.default.statement`
            Object.defineProperty(EXPORTS, "NAME", {
              enumerable: true,
              get: function() {
                return NAMESPACE;
              }
            });
          ` : _template.default.statement`EXPORTS.NAME = NAMESPACE;`)({
          EXPORTS: metadata.exportName,
          NAME: exportName,
          NAMESPACE: cloneNode(srcNamespace)
        }));
      }
      if (sourceMetadata.reexportAll) {
        const statement = buildNamespaceReexport(metadata, cloneNode(srcNamespace), constantReexports);
        statement.loc = sourceMetadata.reexportAll.loc;
        statements.push(statement);
      }
      return statements;
    }
    var ReexportTemplate = {
      constant: _template.default.statement`EXPORTS.EXPORT_NAME = NAMESPACE_IMPORT;`,
      constantComputed: _template.default.statement`EXPORTS["EXPORT_NAME"] = NAMESPACE_IMPORT;`,
      spec: _template.default.statement`
    Object.defineProperty(EXPORTS, "EXPORT_NAME", {
      enumerable: true,
      get: function() {
        return NAMESPACE_IMPORT;
      },
    });
    `
    };
    function buildReexportsFromMeta(meta, metadata, constantReexports) {
      const namespace = metadata.lazy ? callExpression(identifier(metadata.name), []) : identifier(metadata.name);
      const {
        stringSpecifiers
      } = meta;
      return Array.from(metadata.reexports, ([exportName, importName]) => {
        let NAMESPACE_IMPORT = cloneNode(namespace);
        if (importName === "default" && metadata.interop === "node-default") {
        } else if (stringSpecifiers.has(importName)) {
          NAMESPACE_IMPORT = memberExpression(NAMESPACE_IMPORT, stringLiteral2(importName), true);
        } else {
          NAMESPACE_IMPORT = memberExpression(NAMESPACE_IMPORT, identifier(importName));
        }
        const astNodes = {
          EXPORTS: meta.exportName,
          EXPORT_NAME: exportName,
          NAMESPACE_IMPORT
        };
        if (constantReexports || isIdentifier3(NAMESPACE_IMPORT)) {
          if (stringSpecifiers.has(exportName)) {
            return ReexportTemplate.constantComputed(astNodes);
          } else {
            return ReexportTemplate.constant(astNodes);
          }
        } else {
          return ReexportTemplate.spec(astNodes);
        }
      });
    }
    function buildESModuleHeader(metadata, enumerableModuleMeta = false) {
      return (enumerableModuleMeta ? _template.default.statement`
        EXPORTS.__esModule = true;
      ` : _template.default.statement`
        Object.defineProperty(EXPORTS, "__esModule", {
          value: true,
        });
      `)({
        EXPORTS: metadata.exportName
      });
    }
    function buildNamespaceReexport(metadata, namespace, constantReexports) {
      return (constantReexports ? _template.default.statement`
        Object.keys(NAMESPACE).forEach(function(key) {
          if (key === "default" || key === "__esModule") return;
          VERIFY_NAME_LIST;
          if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return;

          EXPORTS[key] = NAMESPACE[key];
        });
      ` : _template.default.statement`
        Object.keys(NAMESPACE).forEach(function(key) {
          if (key === "default" || key === "__esModule") return;
          VERIFY_NAME_LIST;
          if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return;

          Object.defineProperty(EXPORTS, key, {
            enumerable: true,
            get: function() {
              return NAMESPACE[key];
            },
          });
        });
    `)({
        NAMESPACE: namespace,
        EXPORTS: metadata.exportName,
        VERIFY_NAME_LIST: metadata.exportNameListName ? (0, _template.default)`
            if (Object.prototype.hasOwnProperty.call(EXPORTS_LIST, key)) return;
          `({
          EXPORTS_LIST: metadata.exportNameListName
        }) : null
      });
    }
    function buildExportNameListDeclaration(programPath, metadata) {
      const exportedVars = /* @__PURE__ */ Object.create(null);
      for (const data3 of metadata.local.values()) {
        for (const name3 of data3.names) {
          exportedVars[name3] = true;
        }
      }
      let hasReexport = false;
      for (const data3 of metadata.source.values()) {
        for (const exportName of data3.reexports.keys()) {
          exportedVars[exportName] = true;
        }
        for (const exportName of data3.reexportNamespace) {
          exportedVars[exportName] = true;
        }
        hasReexport = hasReexport || !!data3.reexportAll;
      }
      if (!hasReexport || Object.keys(exportedVars).length === 0)
        return null;
      const name2 = programPath.scope.generateUidIdentifier("exportNames");
      delete exportedVars.default;
      return {
        name: name2.name,
        statement: variableDeclaration("var", [variableDeclarator(name2, valueToNode(exportedVars))])
      };
    }
    function buildExportInitializationStatements(programPath, metadata, constantReexports = false, noIncompleteNsImportDetection = false) {
      const initStatements = [];
      for (const [localName, data3] of metadata.local) {
        if (data3.kind === "import") {
        } else if (data3.kind === "hoisted") {
          initStatements.push([data3.names[0], buildInitStatement(metadata, data3.names, identifier(localName))]);
        } else if (!noIncompleteNsImportDetection) {
          for (const exportName of data3.names) {
            initStatements.push([exportName, null]);
          }
        }
      }
      for (const data3 of metadata.source.values()) {
        if (!constantReexports) {
          const reexportsStatements = buildReexportsFromMeta(metadata, data3, false);
          const reexports = [...data3.reexports.keys()];
          for (let i = 0; i < reexportsStatements.length; i++) {
            initStatements.push([reexports[i], reexportsStatements[i]]);
          }
        }
        if (!noIncompleteNsImportDetection) {
          for (const exportName of data3.reexportNamespace) {
            initStatements.push([exportName, null]);
          }
        }
      }
      initStatements.sort(([a], [b]) => {
        if (a < b)
          return -1;
        if (b < a)
          return 1;
        return 0;
      });
      const results = [];
      if (noIncompleteNsImportDetection) {
        for (const [, initStatement] of initStatements) {
          results.push(initStatement);
        }
      } else {
        const chunkSize = 100;
        for (let i = 0; i < initStatements.length; i += chunkSize) {
          let uninitializedExportNames = [];
          for (let j = 0; j < chunkSize && i + j < initStatements.length; j++) {
            const [exportName, initStatement] = initStatements[i + j];
            if (initStatement !== null) {
              if (uninitializedExportNames.length > 0) {
                results.push(buildInitStatement(metadata, uninitializedExportNames, programPath.scope.buildUndefinedNode()));
                uninitializedExportNames = [];
              }
              results.push(initStatement);
            } else {
              uninitializedExportNames.push(exportName);
            }
          }
          if (uninitializedExportNames.length > 0) {
            results.push(buildInitStatement(metadata, uninitializedExportNames, programPath.scope.buildUndefinedNode()));
          }
        }
      }
      return results;
    }
    var InitTemplate = {
      computed: _template.default.expression`EXPORTS["NAME"] = VALUE`,
      default: _template.default.expression`EXPORTS.NAME = VALUE`
    };
    function buildInitStatement(metadata, exportNames, initExpr) {
      const {
        stringSpecifiers,
        exportName: EXPORTS
      } = metadata;
      return expressionStatement(exportNames.reduce((acc, exportName) => {
        const params = {
          EXPORTS,
          NAME: exportName,
          VALUE: acc
        };
        if (stringSpecifiers.has(exportName)) {
          return InitTemplate.computed(params);
        } else {
          return InitTemplate.default(params);
        }
      }, initExpr));
    }
  }
});

// node_modules/@babel/core/node_modules/semver/semver.js
var require_semver = __commonJS({
  "node_modules/@babel/core/node_modules/semver/semver.js"(exports, module2) {
    exports = module2.exports = SemVer;
    var debug;
    if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
      debug = function() {
        var args = Array.prototype.slice.call(arguments, 0);
        args.unshift("SEMVER");
        console.log.apply(console, args);
      };
    } else {
      debug = function() {
      };
    }
    exports.SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
    9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var re = exports.re = [];
    var src = exports.src = [];
    var t3 = exports.tokens = {};
    var R = 0;
    function tok(n) {
      t3[n] = R++;
    }
    tok("NUMERICIDENTIFIER");
    src[t3.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
    tok("NUMERICIDENTIFIERLOOSE");
    src[t3.NUMERICIDENTIFIERLOOSE] = "[0-9]+";
    tok("NONNUMERICIDENTIFIER");
    src[t3.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
    tok("MAINVERSION");
    src[t3.MAINVERSION] = "(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")";
    tok("MAINVERSIONLOOSE");
    src[t3.MAINVERSIONLOOSE] = "(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")";
    tok("PRERELEASEIDENTIFIER");
    src[t3.PRERELEASEIDENTIFIER] = "(?:" + src[t3.NUMERICIDENTIFIER] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
    tok("PRERELEASEIDENTIFIERLOOSE");
    src[t3.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t3.NUMERICIDENTIFIERLOOSE] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
    tok("PRERELEASE");
    src[t3.PRERELEASE] = "(?:-(" + src[t3.PRERELEASEIDENTIFIER] + "(?:\\." + src[t3.PRERELEASEIDENTIFIER] + ")*))";
    tok("PRERELEASELOOSE");
    src[t3.PRERELEASELOOSE] = "(?:-?(" + src[t3.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t3.PRERELEASEIDENTIFIERLOOSE] + ")*))";
    tok("BUILDIDENTIFIER");
    src[t3.BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
    tok("BUILD");
    src[t3.BUILD] = "(?:\\+(" + src[t3.BUILDIDENTIFIER] + "(?:\\." + src[t3.BUILDIDENTIFIER] + ")*))";
    tok("FULL");
    tok("FULLPLAIN");
    src[t3.FULLPLAIN] = "v?" + src[t3.MAINVERSION] + src[t3.PRERELEASE] + "?" + src[t3.BUILD] + "?";
    src[t3.FULL] = "^" + src[t3.FULLPLAIN] + "$";
    tok("LOOSEPLAIN");
    src[t3.LOOSEPLAIN] = "[v=\\s]*" + src[t3.MAINVERSIONLOOSE] + src[t3.PRERELEASELOOSE] + "?" + src[t3.BUILD] + "?";
    tok("LOOSE");
    src[t3.LOOSE] = "^" + src[t3.LOOSEPLAIN] + "$";
    tok("GTLT");
    src[t3.GTLT] = "((?:<|>)?=?)";
    tok("XRANGEIDENTIFIERLOOSE");
    src[t3.XRANGEIDENTIFIERLOOSE] = src[t3.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
    tok("XRANGEIDENTIFIER");
    src[t3.XRANGEIDENTIFIER] = src[t3.NUMERICIDENTIFIER] + "|x|X|\\*";
    tok("XRANGEPLAIN");
    src[t3.XRANGEPLAIN] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:" + src[t3.PRERELEASE] + ")?" + src[t3.BUILD] + "?)?)?";
    tok("XRANGEPLAINLOOSE");
    src[t3.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t3.PRERELEASELOOSE] + ")?" + src[t3.BUILD] + "?)?)?";
    tok("XRANGE");
    src[t3.XRANGE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAIN] + "$";
    tok("XRANGELOOSE");
    src[t3.XRANGELOOSE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAINLOOSE] + "$";
    tok("COERCE");
    src[t3.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
    tok("COERCERTL");
    re[t3.COERCERTL] = new RegExp(src[t3.COERCE], "g");
    tok("LONETILDE");
    src[t3.LONETILDE] = "(?:~>?)";
    tok("TILDETRIM");
    src[t3.TILDETRIM] = "(\\s*)" + src[t3.LONETILDE] + "\\s+";
    re[t3.TILDETRIM] = new RegExp(src[t3.TILDETRIM], "g");
    var tildeTrimReplace = "$1~";
    tok("TILDE");
    src[t3.TILDE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAIN] + "$";
    tok("TILDELOOSE");
    src[t3.TILDELOOSE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAINLOOSE] + "$";
    tok("LONECARET");
    src[t3.LONECARET] = "(?:\\^)";
    tok("CARETTRIM");
    src[t3.CARETTRIM] = "(\\s*)" + src[t3.LONECARET] + "\\s+";
    re[t3.CARETTRIM] = new RegExp(src[t3.CARETTRIM], "g");
    var caretTrimReplace = "$1^";
    tok("CARET");
    src[t3.CARET] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAIN] + "$";
    tok("CARETLOOSE");
    src[t3.CARETLOOSE] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAINLOOSE] + "$";
    tok("COMPARATORLOOSE");
    src[t3.COMPARATORLOOSE] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + ")$|^$";
    tok("COMPARATOR");
    src[t3.COMPARATOR] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.FULLPLAIN] + ")$|^$";
    tok("COMPARATORTRIM");
    src[t3.COMPARATORTRIM] = "(\\s*)" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + "|" + src[t3.XRANGEPLAIN] + ")";
    re[t3.COMPARATORTRIM] = new RegExp(src[t3.COMPARATORTRIM], "g");
    var comparatorTrimReplace = "$1$2$3";
    tok("HYPHENRANGE");
    src[t3.HYPHENRANGE] = "^\\s*(" + src[t3.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t3.XRANGEPLAIN] + ")\\s*$";
    tok("HYPHENRANGELOOSE");
    src[t3.HYPHENRANGELOOSE] = "^\\s*(" + src[t3.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t3.XRANGEPLAINLOOSE] + ")\\s*$";
    tok("STAR");
    src[t3.STAR] = "(<|>)?=?\\s*\\*";
    for (i = 0; i < R; i++) {
      debug(i, src[i]);
      if (!re[i]) {
        re[i] = new RegExp(src[i]);
      }
    }
    var i;
    exports.parse = parse9;
    function parse9(version3, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 !== "string") {
        return null;
      }
      if (version3.length > MAX_LENGTH) {
        return null;
      }
      var r = options.loose ? re[t3.LOOSE] : re[t3.FULL];
      if (!r.test(version3)) {
        return null;
      }
      try {
        return new SemVer(version3, options);
      } catch (er) {
        return null;
      }
    }
    exports.valid = valid2;
    function valid2(version3, options) {
      var v = parse9(version3, options);
      return v ? v.version : null;
    }
    exports.clean = clean2;
    function clean2(version3, options) {
      var s = parse9(version3.trim().replace(/^[=v]+/, ""), options);
      return s ? s.version : null;
    }
    exports.SemVer = SemVer;
    function SemVer(version3, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (version3 instanceof SemVer) {
        if (version3.loose === options.loose) {
          return version3;
        } else {
          version3 = version3.version;
        }
      } else if (typeof version3 !== "string") {
        throw new TypeError("Invalid Version: " + version3);
      }
      if (version3.length > MAX_LENGTH) {
        throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
      }
      if (!(this instanceof SemVer)) {
        return new SemVer(version3, options);
      }
      debug("SemVer", version3, options);
      this.options = options;
      this.loose = !!options.loose;
      var m = version3.trim().match(options.loose ? re[t3.LOOSE] : re[t3.FULL]);
      if (!m) {
        throw new TypeError("Invalid Version: " + version3);
      }
      this.raw = version3;
      this.major = +m[1];
      this.minor = +m[2];
      this.patch = +m[3];
      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
        throw new TypeError("Invalid major version");
      }
      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
        throw new TypeError("Invalid minor version");
      }
      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
        throw new TypeError("Invalid patch version");
      }
      if (!m[4]) {
        this.prerelease = [];
      } else {
        this.prerelease = m[4].split(".").map(function(id) {
          if (/^[0-9]+$/.test(id)) {
            var num = +id;
            if (num >= 0 && num < MAX_SAFE_INTEGER) {
              return num;
            }
          }
          return id;
        });
      }
      this.build = m[5] ? m[5].split(".") : [];
      this.format();
    }
    SemVer.prototype.format = function() {
      this.version = this.major + "." + this.minor + "." + this.patch;
      if (this.prerelease.length) {
        this.version += "-" + this.prerelease.join(".");
      }
      return this.version;
    };
    SemVer.prototype.toString = function() {
      return this.version;
    };
    SemVer.prototype.compare = function(other) {
      debug("SemVer.compare", this.version, this.options, other);
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      return this.compareMain(other) || this.comparePre(other);
    };
    SemVer.prototype.compareMain = function(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
    };
    SemVer.prototype.comparePre = function(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      if (this.prerelease.length && !other.prerelease.length) {
        return -1;
      } else if (!this.prerelease.length && other.prerelease.length) {
        return 1;
      } else if (!this.prerelease.length && !other.prerelease.length) {
        return 0;
      }
      var i2 = 0;
      do {
        var a = this.prerelease[i2];
        var b = other.prerelease[i2];
        debug("prerelease compare", i2, a, b);
        if (a === void 0 && b === void 0) {
          return 0;
        } else if (b === void 0) {
          return 1;
        } else if (a === void 0) {
          return -1;
        } else if (a === b) {
          continue;
        } else {
          return compareIdentifiers(a, b);
        }
      } while (++i2);
    };
    SemVer.prototype.compareBuild = function(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      var i2 = 0;
      do {
        var a = this.build[i2];
        var b = other.build[i2];
        debug("prerelease compare", i2, a, b);
        if (a === void 0 && b === void 0) {
          return 0;
        } else if (b === void 0) {
          return 1;
        } else if (a === void 0) {
          return -1;
        } else if (a === b) {
          continue;
        } else {
          return compareIdentifiers(a, b);
        }
      } while (++i2);
    };
    SemVer.prototype.inc = function(release, identifier) {
      switch (release) {
        case "premajor":
          this.prerelease.length = 0;
          this.patch = 0;
          this.minor = 0;
          this.major++;
          this.inc("pre", identifier);
          break;
        case "preminor":
          this.prerelease.length = 0;
          this.patch = 0;
          this.minor++;
          this.inc("pre", identifier);
          break;
        case "prepatch":
          this.prerelease.length = 0;
          this.inc("patch", identifier);
          this.inc("pre", identifier);
          break;
        case "prerelease":
          if (this.prerelease.length === 0) {
            this.inc("patch", identifier);
          }
          this.inc("pre", identifier);
          break;
        case "major":
          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
            this.major++;
          }
          this.minor = 0;
          this.patch = 0;
          this.prerelease = [];
          break;
        case "minor":
          if (this.patch !== 0 || this.prerelease.length === 0) {
            this.minor++;
          }
          this.patch = 0;
          this.prerelease = [];
          break;
        case "patch":
          if (this.prerelease.length === 0) {
            this.patch++;
          }
          this.prerelease = [];
          break;
        case "pre":
          if (this.prerelease.length === 0) {
            this.prerelease = [0];
          } else {
            var i2 = this.prerelease.length;
            while (--i2 >= 0) {
              if (typeof this.prerelease[i2] === "number") {
                this.prerelease[i2]++;
                i2 = -2;
              }
            }
            if (i2 === -1) {
              this.prerelease.push(0);
            }
          }
          if (identifier) {
            if (this.prerelease[0] === identifier) {
              if (isNaN(this.prerelease[1])) {
                this.prerelease = [identifier, 0];
              }
            } else {
              this.prerelease = [identifier, 0];
            }
          }
          break;
        default:
          throw new Error("invalid increment argument: " + release);
      }
      this.format();
      this.raw = this.version;
      return this;
    };
    exports.inc = inc;
    function inc(version3, release, loose, identifier) {
      if (typeof loose === "string") {
        identifier = loose;
        loose = void 0;
      }
      try {
        return new SemVer(version3, loose).inc(release, identifier).version;
      } catch (er) {
        return null;
      }
    }
    exports.diff = diff;
    function diff(version1, version22) {
      if (eq(version1, version22)) {
        return null;
      } else {
        var v1 = parse9(version1);
        var v2 = parse9(version22);
        var prefix = "";
        if (v1.prerelease.length || v2.prerelease.length) {
          prefix = "pre";
          var defaultResult = "prerelease";
        }
        for (var key2 in v1) {
          if (key2 === "major" || key2 === "minor" || key2 === "patch") {
            if (v1[key2] !== v2[key2]) {
              return prefix + key2;
            }
          }
        }
        return defaultResult;
      }
    }
    exports.compareIdentifiers = compareIdentifiers;
    var numeric = /^[0-9]+$/;
    function compareIdentifiers(a, b) {
      var anum = numeric.test(a);
      var bnum = numeric.test(b);
      if (anum && bnum) {
        a = +a;
        b = +b;
      }
      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
    }
    exports.rcompareIdentifiers = rcompareIdentifiers;
    function rcompareIdentifiers(a, b) {
      return compareIdentifiers(b, a);
    }
    exports.major = major;
    function major(a, loose) {
      return new SemVer(a, loose).major;
    }
    exports.minor = minor;
    function minor(a, loose) {
      return new SemVer(a, loose).minor;
    }
    exports.patch = patch3;
    function patch3(a, loose) {
      return new SemVer(a, loose).patch;
    }
    exports.compare = compare2;
    function compare2(a, b, loose) {
      return new SemVer(a, loose).compare(new SemVer(b, loose));
    }
    exports.compareLoose = compareLoose;
    function compareLoose(a, b) {
      return compare2(a, b, true);
    }
    exports.compareBuild = compareBuild;
    function compareBuild(a, b, loose) {
      var versionA = new SemVer(a, loose);
      var versionB = new SemVer(b, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    }
    exports.rcompare = rcompare;
    function rcompare(a, b, loose) {
      return compare2(b, a, loose);
    }
    exports.sort = sort;
    function sort(list3, loose) {
      return list3.sort(function(a, b) {
        return exports.compareBuild(a, b, loose);
      });
    }
    exports.rsort = rsort;
    function rsort(list3, loose) {
      return list3.sort(function(a, b) {
        return exports.compareBuild(b, a, loose);
      });
    }
    exports.gt = gt;
    function gt(a, b, loose) {
      return compare2(a, b, loose) > 0;
    }
    exports.lt = lt;
    function lt(a, b, loose) {
      return compare2(a, b, loose) < 0;
    }
    exports.eq = eq;
    function eq(a, b, loose) {
      return compare2(a, b, loose) === 0;
    }
    exports.neq = neq;
    function neq(a, b, loose) {
      return compare2(a, b, loose) !== 0;
    }
    exports.gte = gte;
    function gte(a, b, loose) {
      return compare2(a, b, loose) >= 0;
    }
    exports.lte = lte;
    function lte(a, b, loose) {
      return compare2(a, b, loose) <= 0;
    }
    exports.cmp = cmp;
    function cmp(a, op, b, loose) {
      switch (op) {
        case "===":
          if (typeof a === "object")
            a = a.version;
          if (typeof b === "object")
            b = b.version;
          return a === b;
        case "!==":
          if (typeof a === "object")
            a = a.version;
          if (typeof b === "object")
            b = b.version;
          return a !== b;
        case "":
        case "=":
        case "==":
          return eq(a, b, loose);
        case "!=":
          return neq(a, b, loose);
        case ">":
          return gt(a, b, loose);
        case ">=":
          return gte(a, b, loose);
        case "<":
          return lt(a, b, loose);
        case "<=":
          return lte(a, b, loose);
        default:
          throw new TypeError("Invalid operator: " + op);
      }
    }
    exports.Comparator = Comparator;
    function Comparator(comp, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (comp instanceof Comparator) {
        if (comp.loose === !!options.loose) {
          return comp;
        } else {
          comp = comp.value;
        }
      }
      if (!(this instanceof Comparator)) {
        return new Comparator(comp, options);
      }
      debug("comparator", comp, options);
      this.options = options;
      this.loose = !!options.loose;
      this.parse(comp);
      if (this.semver === ANY) {
        this.value = "";
      } else {
        this.value = this.operator + this.semver.version;
      }
      debug("comp", this);
    }
    var ANY = {};
    Comparator.prototype.parse = function(comp) {
      var r = this.options.loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
      var m = comp.match(r);
      if (!m) {
        throw new TypeError("Invalid comparator: " + comp);
      }
      this.operator = m[1] !== void 0 ? m[1] : "";
      if (this.operator === "=") {
        this.operator = "";
      }
      if (!m[2]) {
        this.semver = ANY;
      } else {
        this.semver = new SemVer(m[2], this.options.loose);
      }
    };
    Comparator.prototype.toString = function() {
      return this.value;
    };
    Comparator.prototype.test = function(version3) {
      debug("Comparator.test", version3, this.options.loose);
      if (this.semver === ANY || version3 === ANY) {
        return true;
      }
      if (typeof version3 === "string") {
        try {
          version3 = new SemVer(version3, this.options);
        } catch (er) {
          return false;
        }
      }
      return cmp(version3, this.operator, this.semver, this.options);
    };
    Comparator.prototype.intersects = function(comp, options) {
      if (!(comp instanceof Comparator)) {
        throw new TypeError("a Comparator is required");
      }
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      var rangeTmp;
      if (this.operator === "") {
        if (this.value === "") {
          return true;
        }
        rangeTmp = new Range(comp.value, options);
        return satisfies(this.value, rangeTmp, options);
      } else if (comp.operator === "") {
        if (comp.value === "") {
          return true;
        }
        rangeTmp = new Range(this.value, options);
        return satisfies(comp.semver, rangeTmp, options);
      }
      var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
      var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
      var sameSemVer = this.semver.version === comp.semver.version;
      var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
      var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && ((this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<"));
      var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && ((this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">"));
      return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
    };
    exports.Range = Range;
    function Range(range, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (range instanceof Range) {
        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
          return range;
        } else {
          return new Range(range.raw, options);
        }
      }
      if (range instanceof Comparator) {
        return new Range(range.value, options);
      }
      if (!(this instanceof Range)) {
        return new Range(range, options);
      }
      this.options = options;
      this.loose = !!options.loose;
      this.includePrerelease = !!options.includePrerelease;
      this.raw = range;
      this.set = range.split(/\s*\|\|\s*/).map(function(range2) {
        return this.parseRange(range2.trim());
      }, this).filter(function(c2) {
        return c2.length;
      });
      if (!this.set.length) {
        throw new TypeError("Invalid SemVer Range: " + range);
      }
      this.format();
    }
    Range.prototype.format = function() {
      this.range = this.set.map(function(comps) {
        return comps.join(" ").trim();
      }).join("||").trim();
      return this.range;
    };
    Range.prototype.toString = function() {
      return this.range;
    };
    Range.prototype.parseRange = function(range) {
      var loose = this.options.loose;
      range = range.trim();
      var hr = loose ? re[t3.HYPHENRANGELOOSE] : re[t3.HYPHENRANGE];
      range = range.replace(hr, hyphenReplace);
      debug("hyphen replace", range);
      range = range.replace(re[t3.COMPARATORTRIM], comparatorTrimReplace);
      debug("comparator trim", range, re[t3.COMPARATORTRIM]);
      range = range.replace(re[t3.TILDETRIM], tildeTrimReplace);
      range = range.replace(re[t3.CARETTRIM], caretTrimReplace);
      range = range.split(/\s+/).join(" ");
      var compRe = loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
      var set = range.split(" ").map(function(comp) {
        return parseComparator(comp, this.options);
      }, this).join(" ").split(/\s+/);
      if (this.options.loose) {
        set = set.filter(function(comp) {
          return !!comp.match(compRe);
        });
      }
      set = set.map(function(comp) {
        return new Comparator(comp, this.options);
      }, this);
      return set;
    };
    Range.prototype.intersects = function(range, options) {
      if (!(range instanceof Range)) {
        throw new TypeError("a Range is required");
      }
      return this.set.some(function(thisComparators) {
        return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {
          return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {
            return rangeComparators.every(function(rangeComparator) {
              return thisComparator.intersects(rangeComparator, options);
            });
          });
        });
      });
    };
    function isSatisfiable(comparators, options) {
      var result = true;
      var remainingComparators = comparators.slice();
      var testComparator = remainingComparators.pop();
      while (result && remainingComparators.length) {
        result = remainingComparators.every(function(otherComparator) {
          return testComparator.intersects(otherComparator, options);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    }
    exports.toComparators = toComparators;
    function toComparators(range, options) {
      return new Range(range, options).set.map(function(comp) {
        return comp.map(function(c2) {
          return c2.value;
        }).join(" ").trim().split(" ");
      });
    }
    function parseComparator(comp, options) {
      debug("comp", comp, options);
      comp = replaceCarets(comp, options);
      debug("caret", comp);
      comp = replaceTildes(comp, options);
      debug("tildes", comp);
      comp = replaceXRanges(comp, options);
      debug("xrange", comp);
      comp = replaceStars(comp, options);
      debug("stars", comp);
      return comp;
    }
    function isX(id) {
      return !id || id.toLowerCase() === "x" || id === "*";
    }
    function replaceTildes(comp, options) {
      return comp.trim().split(/\s+/).map(function(comp2) {
        return replaceTilde(comp2, options);
      }).join(" ");
    }
    function replaceTilde(comp, options) {
      var r = options.loose ? re[t3.TILDELOOSE] : re[t3.TILDE];
      return comp.replace(r, function(_, M, m, p, pr) {
        debug("tilde", comp, _, M, m, p, pr);
        var ret;
        if (isX(M)) {
          ret = "";
        } else if (isX(m)) {
          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
        } else if (isX(p)) {
          ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
        } else if (pr) {
          debug("replaceTilde pr", pr);
          ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
        } else {
          ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
        }
        debug("tilde return", ret);
        return ret;
      });
    }
    function replaceCarets(comp, options) {
      return comp.trim().split(/\s+/).map(function(comp2) {
        return replaceCaret(comp2, options);
      }).join(" ");
    }
    function replaceCaret(comp, options) {
      debug("caret", comp, options);
      var r = options.loose ? re[t3.CARETLOOSE] : re[t3.CARET];
      return comp.replace(r, function(_, M, m, p, pr) {
        debug("caret", comp, _, M, m, p, pr);
        var ret;
        if (isX(M)) {
          ret = "";
        } else if (isX(m)) {
          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
        } else if (isX(p)) {
          if (M === "0") {
            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
          } else {
            ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
          }
        } else if (pr) {
          debug("replaceCaret pr", pr);
          if (M === "0") {
            if (m === "0") {
              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
            } else {
              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
            }
          } else {
            ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
          }
        } else {
          debug("no pr");
          if (M === "0") {
            if (m === "0") {
              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
            } else {
              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
            }
          } else {
            ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
          }
        }
        debug("caret return", ret);
        return ret;
      });
    }
    function replaceXRanges(comp, options) {
      debug("replaceXRanges", comp, options);
      return comp.split(/\s+/).map(function(comp2) {
        return replaceXRange(comp2, options);
      }).join(" ");
    }
    function replaceXRange(comp, options) {
      comp = comp.trim();
      var r = options.loose ? re[t3.XRANGELOOSE] : re[t3.XRANGE];
      return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
        debug("xRange", comp, ret, gtlt, M, m, p, pr);
        var xM = isX(M);
        var xm = xM || isX(m);
        var xp = xm || isX(p);
        var anyX = xp;
        if (gtlt === "=" && anyX) {
          gtlt = "";
        }
        pr = options.includePrerelease ? "-0" : "";
        if (xM) {
          if (gtlt === ">" || gtlt === "<") {
            ret = "<0.0.0-0";
          } else {
            ret = "*";
          }
        } else if (gtlt && anyX) {
          if (xm) {
            m = 0;
          }
          p = 0;
          if (gtlt === ">") {
            gtlt = ">=";
            if (xm) {
              M = +M + 1;
              m = 0;
              p = 0;
            } else {
              m = +m + 1;
              p = 0;
            }
          } else if (gtlt === "<=") {
            gtlt = "<";
            if (xm) {
              M = +M + 1;
            } else {
              m = +m + 1;
            }
          }
          ret = gtlt + M + "." + m + "." + p + pr;
        } else if (xm) {
          ret = ">=" + M + ".0.0" + pr + " <" + (+M + 1) + ".0.0" + pr;
        } else if (xp) {
          ret = ">=" + M + "." + m + ".0" + pr + " <" + M + "." + (+m + 1) + ".0" + pr;
        }
        debug("xRange return", ret);
        return ret;
      });
    }
    function replaceStars(comp, options) {
      debug("replaceStars", comp, options);
      return comp.trim().replace(re[t3.STAR], "");
    }
    function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
      if (isX(fM)) {
        from = "";
      } else if (isX(fm)) {
        from = ">=" + fM + ".0.0";
      } else if (isX(fp)) {
        from = ">=" + fM + "." + fm + ".0";
      } else {
        from = ">=" + from;
      }
      if (isX(tM)) {
        to = "";
      } else if (isX(tm)) {
        to = "<" + (+tM + 1) + ".0.0";
      } else if (isX(tp)) {
        to = "<" + tM + "." + (+tm + 1) + ".0";
      } else if (tpr) {
        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
      } else {
        to = "<=" + to;
      }
      return (from + " " + to).trim();
    }
    Range.prototype.test = function(version3) {
      if (!version3) {
        return false;
      }
      if (typeof version3 === "string") {
        try {
          version3 = new SemVer(version3, this.options);
        } catch (er) {
          return false;
        }
      }
      for (var i2 = 0; i2 < this.set.length; i2++) {
        if (testSet(this.set[i2], version3, this.options)) {
          return true;
        }
      }
      return false;
    };
    function testSet(set, version3, options) {
      for (var i2 = 0; i2 < set.length; i2++) {
        if (!set[i2].test(version3)) {
          return false;
        }
      }
      if (version3.prerelease.length && !options.includePrerelease) {
        for (i2 = 0; i2 < set.length; i2++) {
          debug(set[i2].semver);
          if (set[i2].semver === ANY) {
            continue;
          }
          if (set[i2].semver.prerelease.length > 0) {
            var allowed = set[i2].semver;
            if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    }
    exports.satisfies = satisfies;
    function satisfies(version3, range, options) {
      try {
        range = new Range(range, options);
      } catch (er) {
        return false;
      }
      return range.test(version3);
    }
    exports.maxSatisfying = maxSatisfying;
    function maxSatisfying(versions, range, options) {
      var max = null;
      var maxSV = null;
      try {
        var rangeObj = new Range(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach(function(v) {
        if (rangeObj.test(v)) {
          if (!max || maxSV.compare(v) === -1) {
            max = v;
            maxSV = new SemVer(max, options);
          }
        }
      });
      return max;
    }
    exports.minSatisfying = minSatisfying;
    function minSatisfying(versions, range, options) {
      var min = null;
      var minSV = null;
      try {
        var rangeObj = new Range(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach(function(v) {
        if (rangeObj.test(v)) {
          if (!min || minSV.compare(v) === 1) {
            min = v;
            minSV = new SemVer(min, options);
          }
        }
      });
      return min;
    }
    exports.minVersion = minVersion;
    function minVersion(range, loose) {
      range = new Range(range, loose);
      var minver = new SemVer("0.0.0");
      if (range.test(minver)) {
        return minver;
      }
      minver = new SemVer("0.0.0-0");
      if (range.test(minver)) {
        return minver;
      }
      minver = null;
      for (var i2 = 0; i2 < range.set.length; ++i2) {
        var comparators = range.set[i2];
        comparators.forEach(function(comparator) {
          var compver = new SemVer(comparator.semver.version);
          switch (comparator.operator) {
            case ">":
              if (compver.prerelease.length === 0) {
                compver.patch++;
              } else {
                compver.prerelease.push(0);
              }
              compver.raw = compver.format();
            case "":
            case ">=":
              if (!minver || gt(minver, compver)) {
                minver = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            default:
              throw new Error("Unexpected operation: " + comparator.operator);
          }
        });
      }
      if (minver && range.test(minver)) {
        return minver;
      }
      return null;
    }
    exports.validRange = validRange;
    function validRange(range, options) {
      try {
        return new Range(range, options).range || "*";
      } catch (er) {
        return null;
      }
    }
    exports.ltr = ltr;
    function ltr(version3, range, options) {
      return outside(version3, range, "<", options);
    }
    exports.gtr = gtr;
    function gtr(version3, range, options) {
      return outside(version3, range, ">", options);
    }
    exports.outside = outside;
    function outside(version3, range, hilo, options) {
      version3 = new SemVer(version3, options);
      range = new Range(range, options);
      var gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt;
          ltefn = lte;
          ltfn = lt;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt;
          ltefn = gte;
          ltfn = gt;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies(version3, range, options)) {
        return false;
      }
      for (var i2 = 0; i2 < range.set.length; ++i2) {
        var comparators = range.set[i2];
        var high = null;
        var low = null;
        comparators.forEach(function(comparator) {
          if (comparator.semver === ANY) {
            comparator = new Comparator(">=0.0.0");
          }
          high = high || comparator;
          low = low || comparator;
          if (gtfn(comparator.semver, high.semver, options)) {
            high = comparator;
          } else if (ltfn(comparator.semver, low.semver, options)) {
            low = comparator;
          }
        });
        if (high.operator === comp || high.operator === ecomp) {
          return false;
        }
        if ((!low.operator || low.operator === comp) && ltefn(version3, low.semver)) {
          return false;
        } else if (low.operator === ecomp && ltfn(version3, low.semver)) {
          return false;
        }
      }
      return true;
    }
    exports.prerelease = prerelease;
    function prerelease(version3, options) {
      var parsed = parse9(version3, options);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    }
    exports.intersects = intersects;
    function intersects(r1, r2, options) {
      r1 = new Range(r1, options);
      r2 = new Range(r2, options);
      return r1.intersects(r2);
    }
    exports.coerce = coerce;
    function coerce(version3, options) {
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 === "number") {
        version3 = String(version3);
      }
      if (typeof version3 !== "string") {
        return null;
      }
      options = options || {};
      var match = null;
      if (!options.rtl) {
        match = version3.match(re[t3.COERCE]);
      } else {
        var next;
        while ((next = re[t3.COERCERTL].exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
          if (!match || next.index + next[0].length !== match.index + match[0].length) {
            match = next;
          }
          re[t3.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
        }
        re[t3.COERCERTL].lastIndex = -1;
      }
      if (match === null) {
        return null;
      }
      return parse9(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options);
    }
  }
});

// node_modules/@babel/core/lib/transformation/file/file.js
var require_file = __commonJS({
  "node_modules/@babel/core/lib/transformation/file/file.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    function helpers() {
      const data3 = require_lib14();
      helpers = function() {
        return data3;
      };
      return data3;
    }
    function _traverse() {
      const data3 = require_lib13();
      _traverse = function() {
        return data3;
      };
      return data3;
    }
    function _codeFrame() {
      const data3 = require_lib8();
      _codeFrame = function() {
        return data3;
      };
      return data3;
    }
    function _t() {
      const data3 = require_lib3();
      _t = function() {
        return data3;
      };
      return data3;
    }
    function _helperModuleTransforms() {
      const data3 = require_lib17();
      _helperModuleTransforms = function() {
        return data3;
      };
      return data3;
    }
    function _semver() {
      const data3 = require_semver();
      _semver = function() {
        return data3;
      };
      return data3;
    }
    var {
      cloneNode,
      interpreterDirective
    } = _t();
    var errorVisitor = {
      enter(path, state) {
        const loc = path.node.loc;
        if (loc) {
          state.loc = loc;
          path.stop();
        }
      }
    };
    var File = class {
      constructor(options, {
        code: code2,
        ast,
        inputMap
      }) {
        this._map = /* @__PURE__ */ new Map();
        this.opts = void 0;
        this.declarations = {};
        this.path = void 0;
        this.ast = void 0;
        this.scope = void 0;
        this.metadata = {};
        this.code = "";
        this.inputMap = void 0;
        this.hub = {
          file: this,
          getCode: () => this.code,
          getScope: () => this.scope,
          addHelper: this.addHelper.bind(this),
          buildError: this.buildCodeFrameError.bind(this)
        };
        this.opts = options;
        this.code = code2;
        this.ast = ast;
        this.inputMap = inputMap;
        this.path = _traverse().NodePath.get({
          hub: this.hub,
          parentPath: null,
          parent: this.ast,
          container: this.ast,
          key: "program"
        }).setContext();
        this.scope = this.path.scope;
      }
      get shebang() {
        const {
          interpreter
        } = this.path.node;
        return interpreter ? interpreter.value : "";
      }
      set shebang(value2) {
        if (value2) {
          this.path.get("interpreter").replaceWith(interpreterDirective(value2));
        } else {
          this.path.get("interpreter").remove();
        }
      }
      set(key2, val) {
        if (key2 === "helpersNamespace") {
          throw new Error("Babel 7.0.0-beta.56 has dropped support for the 'helpersNamespace' utility.If you are using @babel/plugin-external-helpers you will need to use a newer version than the one you currently have installed. If you have your own implementation, you'll want to explore using 'helperGenerator' alongside 'file.availableHelper()'.");
        }
        this._map.set(key2, val);
      }
      get(key2) {
        return this._map.get(key2);
      }
      has(key2) {
        return this._map.has(key2);
      }
      getModuleName() {
        return (0, _helperModuleTransforms().getModuleName)(this.opts, this.opts);
      }
      addImport() {
        throw new Error("This API has been removed. If you're looking for this functionality in Babel 7, you should import the '@babel/helper-module-imports' module and use the functions exposed  from that module, such as 'addNamed' or 'addDefault'.");
      }
      availableHelper(name2, versionRange) {
        let minVersion;
        try {
          minVersion = helpers().minVersion(name2);
        } catch (err) {
          if (err.code !== "BABEL_HELPER_UNKNOWN")
            throw err;
          return false;
        }
        if (typeof versionRange !== "string")
          return true;
        if (_semver().valid(versionRange))
          versionRange = `^${versionRange}`;
        return !_semver().intersects(`<${minVersion}`, versionRange) && !_semver().intersects(`>=8.0.0`, versionRange);
      }
      addHelper(name2) {
        const declar = this.declarations[name2];
        if (declar)
          return cloneNode(declar);
        const generator = this.get("helperGenerator");
        if (generator) {
          const res = generator(name2);
          if (res)
            return res;
        }
        helpers().ensure(name2, File);
        const uid = this.declarations[name2] = this.scope.generateUidIdentifier(name2);
        const dependencies = {};
        for (const dep of helpers().getDependencies(name2)) {
          dependencies[dep] = this.addHelper(dep);
        }
        const {
          nodes,
          globals
        } = helpers().get(name2, (dep) => dependencies[dep], uid, Object.keys(this.scope.getAllBindings()));
        globals.forEach((name3) => {
          if (this.path.scope.hasBinding(name3, true)) {
            this.path.scope.rename(name3);
          }
        });
        nodes.forEach((node2) => {
          node2._compact = true;
        });
        this.path.unshiftContainer("body", nodes);
        this.path.get("body").forEach((path) => {
          if (nodes.indexOf(path.node) === -1)
            return;
          if (path.isVariableDeclaration())
            this.scope.registerDeclaration(path);
        });
        return uid;
      }
      addTemplateObject() {
        throw new Error("This function has been moved into the template literal transform itself.");
      }
      buildCodeFrameError(node2, msg, _Error = SyntaxError) {
        let loc = node2 && (node2.loc || node2._loc);
        if (!loc && node2) {
          const state = {
            loc: null
          };
          (0, _traverse().default)(node2, errorVisitor, this.scope, state);
          loc = state.loc;
          let txt = "This is an error on an internal node. Probably an internal error.";
          if (loc)
            txt += " Location has been estimated.";
          msg += ` (${txt})`;
        }
        if (loc) {
          const {
            highlightCode = true
          } = this.opts;
          msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
            start: {
              line: loc.start.line,
              column: loc.start.column + 1
            },
            end: loc.end && loc.start.line === loc.end.line ? {
              line: loc.end.line,
              column: loc.end.column + 1
            } : void 0
          }, {
            highlightCode
          });
        }
        return new _Error(msg);
      }
    };
    exports.default = File;
  }
});

// node_modules/@babel/core/lib/tools/build-external-helpers.js
var require_build_external_helpers = __commonJS({
  "node_modules/@babel/core/lib/tools/build-external-helpers.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = _default;
    function helpers() {
      const data3 = require_lib14();
      helpers = function() {
        return data3;
      };
      return data3;
    }
    function _generator() {
      const data3 = require_lib4();
      _generator = function() {
        return data3;
      };
      return data3;
    }
    function _template() {
      const data3 = require_lib11();
      _template = function() {
        return data3;
      };
      return data3;
    }
    function _t() {
      const data3 = require_lib3();
      _t = function() {
        return data3;
      };
      return data3;
    }
    var _file = require_file();
    var {
      arrayExpression,
      assignmentExpression,
      binaryExpression,
      blockStatement,
      callExpression,
      cloneNode,
      conditionalExpression,
      exportNamedDeclaration,
      exportSpecifier,
      expressionStatement,
      functionExpression,
      identifier,
      memberExpression,
      objectExpression,
      program,
      stringLiteral: stringLiteral2,
      unaryExpression,
      variableDeclaration,
      variableDeclarator
    } = _t();
    var buildUmdWrapper = (replacements) => _template().default.statement`
    (function (root, factory) {
      if (typeof define === "function" && define.amd) {
        define(AMD_ARGUMENTS, factory);
      } else if (typeof exports === "object") {
        factory(COMMON_ARGUMENTS);
      } else {
        factory(BROWSER_ARGUMENTS);
      }
    })(UMD_ROOT, function (FACTORY_PARAMETERS) {
      FACTORY_BODY
    });
  `(replacements);
    function buildGlobal(allowlist) {
      const namespace = identifier("babelHelpers");
      const body = [];
      const container = functionExpression(null, [identifier("global")], blockStatement(body));
      const tree = program([expressionStatement(callExpression(container, [conditionalExpression(binaryExpression("===", unaryExpression("typeof", identifier("global")), stringLiteral2("undefined")), identifier("self"), identifier("global"))]))]);
      body.push(variableDeclaration("var", [variableDeclarator(namespace, assignmentExpression("=", memberExpression(identifier("global"), namespace), objectExpression([])))]));
      buildHelpers(body, namespace, allowlist);
      return tree;
    }
    function buildModule(allowlist) {
      const body = [];
      const refs = buildHelpers(body, null, allowlist);
      body.unshift(exportNamedDeclaration(null, Object.keys(refs).map((name2) => {
        return exportSpecifier(cloneNode(refs[name2]), identifier(name2));
      })));
      return program(body, [], "module");
    }
    function buildUmd(allowlist) {
      const namespace = identifier("babelHelpers");
      const body = [];
      body.push(variableDeclaration("var", [variableDeclarator(namespace, identifier("global"))]));
      buildHelpers(body, namespace, allowlist);
      return program([buildUmdWrapper({
        FACTORY_PARAMETERS: identifier("global"),
        BROWSER_ARGUMENTS: assignmentExpression("=", memberExpression(identifier("root"), namespace), objectExpression([])),
        COMMON_ARGUMENTS: identifier("exports"),
        AMD_ARGUMENTS: arrayExpression([stringLiteral2("exports")]),
        FACTORY_BODY: body,
        UMD_ROOT: identifier("this")
      })]);
    }
    function buildVar(allowlist) {
      const namespace = identifier("babelHelpers");
      const body = [];
      body.push(variableDeclaration("var", [variableDeclarator(namespace, objectExpression([]))]));
      const tree = program(body);
      buildHelpers(body, namespace, allowlist);
      body.push(expressionStatement(namespace));
      return tree;
    }
    function buildHelpers(body, namespace, allowlist) {
      const getHelperReference = (name2) => {
        return namespace ? memberExpression(namespace, identifier(name2)) : identifier(`_${name2}`);
      };
      const refs = {};
      helpers().list.forEach(function(name2) {
        if (allowlist && allowlist.indexOf(name2) < 0)
          return;
        const ref3 = refs[name2] = getHelperReference(name2);
        helpers().ensure(name2, _file.default);
        const {
          nodes
        } = helpers().get(name2, getHelperReference, ref3);
        body.push(...nodes);
      });
      return refs;
    }
    function _default(allowlist, outputType = "global") {
      let tree;
      const build = {
        global: buildGlobal,
        module: buildModule,
        umd: buildUmd,
        var: buildVar
      }[outputType];
      if (build) {
        tree = build(allowlist);
      } else {
        throw new Error(`Unsupported output type ${outputType}`);
      }
      return (0, _generator().default)(tree).code;
    }
  }
});

// node_modules/gensync/index.js
var require_gensync = __commonJS({
  "node_modules/gensync/index.js"(exports, module2) {
    "use strict";
    var GENSYNC_START = Symbol.for("gensync:v1:start");
    var GENSYNC_SUSPEND = Symbol.for("gensync:v1:suspend");
    var GENSYNC_EXPECTED_START = "GENSYNC_EXPECTED_START";
    var GENSYNC_EXPECTED_SUSPEND = "GENSYNC_EXPECTED_SUSPEND";
    var GENSYNC_OPTIONS_ERROR = "GENSYNC_OPTIONS_ERROR";
    var GENSYNC_RACE_NONEMPTY = "GENSYNC_RACE_NONEMPTY";
    var GENSYNC_ERRBACK_NO_CALLBACK = "GENSYNC_ERRBACK_NO_CALLBACK";
    module2.exports = Object.assign(
      function gensync(optsOrFn) {
        let genFn = optsOrFn;
        if (typeof optsOrFn !== "function") {
          genFn = newGenerator(optsOrFn);
        } else {
          genFn = wrapGenerator(optsOrFn);
        }
        return Object.assign(genFn, makeFunctionAPI(genFn));
      },
      {
        all: buildOperation({
          name: "all",
          arity: 1,
          sync: function(args) {
            const items = Array.from(args[0]);
            return items.map((item) => evaluateSync(item));
          },
          async: function(args, resolve, reject) {
            const items = Array.from(args[0]);
            if (items.length === 0) {
              Promise.resolve().then(() => resolve([]));
              return;
            }
            let count = 0;
            const results = items.map(() => void 0);
            items.forEach((item, i) => {
              evaluateAsync(
                item,
                (val) => {
                  results[i] = val;
                  count += 1;
                  if (count === results.length)
                    resolve(results);
                },
                reject
              );
            });
          }
        }),
        race: buildOperation({
          name: "race",
          arity: 1,
          sync: function(args) {
            const items = Array.from(args[0]);
            if (items.length === 0) {
              throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY);
            }
            return evaluateSync(items[0]);
          },
          async: function(args, resolve, reject) {
            const items = Array.from(args[0]);
            if (items.length === 0) {
              throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY);
            }
            for (const item of items) {
              evaluateAsync(item, resolve, reject);
            }
          }
        })
      }
    );
    function makeFunctionAPI(genFn) {
      const fns = {
        sync: function(...args) {
          return evaluateSync(genFn.apply(this, args));
        },
        async: function(...args) {
          return new Promise((resolve, reject) => {
            evaluateAsync(genFn.apply(this, args), resolve, reject);
          });
        },
        errback: function(...args) {
          const cb = args.pop();
          if (typeof cb !== "function") {
            throw makeError(
              "Asynchronous function called without callback",
              GENSYNC_ERRBACK_NO_CALLBACK
            );
          }
          let gen;
          try {
            gen = genFn.apply(this, args);
          } catch (err) {
            cb(err);
            return;
          }
          evaluateAsync(gen, (val) => cb(void 0, val), (err) => cb(err));
        }
      };
      return fns;
    }
    function assertTypeof(type, name2, value2, allowUndefined) {
      if (typeof value2 === type || allowUndefined && typeof value2 === "undefined") {
        return;
      }
      let msg;
      if (allowUndefined) {
        msg = `Expected opts.${name2} to be either a ${type}, or undefined.`;
      } else {
        msg = `Expected opts.${name2} to be a ${type}.`;
      }
      throw makeError(msg, GENSYNC_OPTIONS_ERROR);
    }
    function makeError(msg, code2) {
      return Object.assign(new Error(msg), { code: code2 });
    }
    function newGenerator({ name: name2, arity, sync, async, errback }) {
      assertTypeof(
        "string",
        "name",
        name2,
        true
        /* allowUndefined */
      );
      assertTypeof(
        "number",
        "arity",
        arity,
        true
        /* allowUndefined */
      );
      assertTypeof("function", "sync", sync);
      assertTypeof(
        "function",
        "async",
        async,
        true
        /* allowUndefined */
      );
      assertTypeof(
        "function",
        "errback",
        errback,
        true
        /* allowUndefined */
      );
      if (async && errback) {
        throw makeError(
          "Expected one of either opts.async or opts.errback, but got _both_.",
          GENSYNC_OPTIONS_ERROR
        );
      }
      if (typeof name2 !== "string") {
        let fnName;
        if (errback && errback.name && errback.name !== "errback") {
          fnName = errback.name;
        }
        if (async && async.name && async.name !== "async") {
          fnName = async.name.replace(/Async$/, "");
        }
        if (sync && sync.name && sync.name !== "sync") {
          fnName = sync.name.replace(/Sync$/, "");
        }
        if (typeof fnName === "string") {
          name2 = fnName;
        }
      }
      if (typeof arity !== "number") {
        arity = sync.length;
      }
      return buildOperation({
        name: name2,
        arity,
        sync: function(args) {
          return sync.apply(this, args);
        },
        async: function(args, resolve, reject) {
          if (async) {
            async.apply(this, args).then(resolve, reject);
          } else if (errback) {
            errback.call(this, ...args, (err, value2) => {
              if (err == null)
                resolve(value2);
              else
                reject(err);
            });
          } else {
            resolve(sync.apply(this, args));
          }
        }
      });
    }
    function wrapGenerator(genFn) {
      return setFunctionMetadata(genFn.name, genFn.length, function(...args) {
        return genFn.apply(this, args);
      });
    }
    function buildOperation({ name: name2, arity, sync, async }) {
      return setFunctionMetadata(name2, arity, function* (...args) {
        const resume = yield GENSYNC_START;
        if (!resume) {
          const res = sync.call(this, args);
          return res;
        }
        let result;
        try {
          async.call(
            this,
            args,
            (value2) => {
              if (result)
                return;
              result = { value: value2 };
              resume();
            },
            (err) => {
              if (result)
                return;
              result = { err };
              resume();
            }
          );
        } catch (err) {
          result = { err };
          resume();
        }
        yield GENSYNC_SUSPEND;
        if (result.hasOwnProperty("err")) {
          throw result.err;
        }
        return result.value;
      });
    }
    function evaluateSync(gen) {
      let value2;
      while (!({ value: value2 } = gen.next()).done) {
        assertStart(value2, gen);
      }
      return value2;
    }
    function evaluateAsync(gen, resolve, reject) {
      (function step() {
        try {
          let value2;
          while (!({ value: value2 } = gen.next()).done) {
            assertStart(value2, gen);
            let sync = true;
            let didSyncResume = false;
            const out = gen.next(() => {
              if (sync) {
                didSyncResume = true;
              } else {
                step();
              }
            });
            sync = false;
            assertSuspend(out, gen);
            if (!didSyncResume) {
              return;
            }
          }
          return resolve(value2);
        } catch (err) {
          return reject(err);
        }
      })();
    }
    function assertStart(value2, gen) {
      if (value2 === GENSYNC_START)
        return;
      throwError(
        gen,
        makeError(
          `Got unexpected yielded value in gensync generator: ${JSON.stringify(
            value2
          )}. Did you perhaps mean to use 'yield*' instead of 'yield'?`,
          GENSYNC_EXPECTED_START
        )
      );
    }
    function assertSuspend({ value: value2, done }, gen) {
      if (!done && value2 === GENSYNC_SUSPEND)
        return;
      throwError(
        gen,
        makeError(
          done ? "Unexpected generator completion. If you get this, it is probably a gensync bug." : `Expected GENSYNC_SUSPEND, got ${JSON.stringify(
            value2
          )}. If you get this, it is probably a gensync bug.`,
          GENSYNC_EXPECTED_SUSPEND
        )
      );
    }
    function throwError(gen, err) {
      if (gen.throw)
        gen.throw(err);
      throw err;
    }
    function setFunctionMetadata(name2, arity, fn) {
      if (typeof name2 === "string") {
        const nameDesc = Object.getOwnPropertyDescriptor(fn, "name");
        if (!nameDesc || nameDesc.configurable) {
          Object.defineProperty(
            fn,
            "name",
            Object.assign(nameDesc || {}, {
              configurable: true,
              value: name2
            })
          );
        }
      }
      if (typeof arity === "number") {
        const lengthDesc = Object.getOwnPropertyDescriptor(fn, "length");
        if (!lengthDesc || lengthDesc.configurable) {
          Object.defineProperty(
            fn,
            "length",
            Object.assign(lengthDesc || {}, {
              configurable: true,
              value: arity
            })
          );
        }
      }
      return fn;
    }
  }
});

// node_modules/@babel/core/lib/gensync-utils/async.js
var require_async = __commonJS({
  "node_modules/@babel/core/lib/gensync-utils/async.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.forwardAsync = forwardAsync;
    exports.isAsync = void 0;
    exports.isThenable = isThenable;
    exports.maybeAsync = maybeAsync;
    exports.waitFor = exports.onFirstPause = void 0;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key2, arg) {
      try {
        var info = gen[key2](arg);
        var value2 = info.value;
      } catch (error) {
        reject(error);
        return;
      }
      if (info.done) {
        resolve(value2);
      } else {
        Promise.resolve(value2).then(_next, _throw);
      }
    }
    function _asyncToGenerator(fn) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve, reject) {
          var gen = fn.apply(self2, args);
          function _next(value2) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value2);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
          }
          _next(void 0);
        });
      };
    }
    var runGenerator = _gensync()(function* (item) {
      return yield* item;
    });
    var isAsync = _gensync()({
      sync: () => false,
      errback: (cb) => cb(null, true)
    });
    exports.isAsync = isAsync;
    function maybeAsync(fn, message) {
      return _gensync()({
        sync(...args) {
          const result = fn.apply(this, args);
          if (isThenable(result))
            throw new Error(message);
          return result;
        },
        async(...args) {
          return Promise.resolve(fn.apply(this, args));
        }
      });
    }
    var withKind = _gensync()({
      sync: (cb) => cb("sync"),
      async: function() {
        var _ref = _asyncToGenerator(function* (cb) {
          return cb("async");
        });
        return function async(_x) {
          return _ref.apply(this, arguments);
        };
      }()
    });
    function forwardAsync(action, cb) {
      const g = _gensync()(action);
      return withKind((kind) => {
        const adapted = g[kind];
        return cb(adapted);
      });
    }
    var onFirstPause = _gensync()({
      name: "onFirstPause",
      arity: 2,
      sync: function(item) {
        return runGenerator.sync(item);
      },
      errback: function(item, firstPause, cb) {
        let completed = false;
        runGenerator.errback(item, (err, value2) => {
          completed = true;
          cb(err, value2);
        });
        if (!completed) {
          firstPause();
        }
      }
    });
    exports.onFirstPause = onFirstPause;
    var waitFor = _gensync()({
      sync: (x) => x,
      async: function() {
        var _ref2 = _asyncToGenerator(function* (x) {
          return x;
        });
        return function async(_x2) {
          return _ref2.apply(this, arguments);
        };
      }()
    });
    exports.waitFor = waitFor;
    function isThenable(val) {
      return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
    }
  }
});

// node_modules/@babel/core/lib/config/util.js
var require_util2 = __commonJS({
  "node_modules/@babel/core/lib/config/util.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isIterableIterator = isIterableIterator;
    exports.mergeOptions = mergeOptions;
    function mergeOptions(target, source2) {
      for (const k of Object.keys(source2)) {
        if ((k === "parserOpts" || k === "generatorOpts" || k === "assumptions") && source2[k]) {
          const parserOpts = source2[k];
          const targetObj = target[k] || (target[k] = {});
          mergeDefaultFields(targetObj, parserOpts);
        } else {
          const val = source2[k];
          if (val !== void 0)
            target[k] = val;
        }
      }
    }
    function mergeDefaultFields(target, source2) {
      for (const k of Object.keys(source2)) {
        const val = source2[k];
        if (val !== void 0)
          target[k] = val;
      }
    }
    function isIterableIterator(value2) {
      return !!value2 && typeof value2.next === "function" && typeof value2[Symbol.iterator] === "function";
    }
  }
});

// node_modules/@babel/core/lib/config/caching.js
var require_caching = __commonJS({
  "node_modules/@babel/core/lib/config/caching.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.assertSimpleType = assertSimpleType;
    exports.makeStrongCache = makeStrongCache;
    exports.makeStrongCacheSync = makeStrongCacheSync;
    exports.makeWeakCache = makeWeakCache;
    exports.makeWeakCacheSync = makeWeakCacheSync;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _async = require_async();
    var _util = require_util2();
    var synchronize = (gen) => {
      return _gensync()(gen).sync;
    };
    function* genTrue() {
      return true;
    }
    function makeWeakCache(handler) {
      return makeCachedFunction(WeakMap, handler);
    }
    function makeWeakCacheSync(handler) {
      return synchronize(makeWeakCache(handler));
    }
    function makeStrongCache(handler) {
      return makeCachedFunction(Map, handler);
    }
    function makeStrongCacheSync(handler) {
      return synchronize(makeStrongCache(handler));
    }
    function makeCachedFunction(CallCache, handler) {
      const callCacheSync = new CallCache();
      const callCacheAsync = new CallCache();
      const futureCache = new CallCache();
      return function* cachedFunction(arg, data3) {
        const asyncContext = yield* (0, _async.isAsync)();
        const callCache = asyncContext ? callCacheAsync : callCacheSync;
        const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data3);
        if (cached.valid)
          return cached.value;
        const cache = new CacheConfigurator(data3);
        const handlerResult = handler(arg, cache);
        let finishLock;
        let value2;
        if ((0, _util.isIterableIterator)(handlerResult)) {
          value2 = yield* (0, _async.onFirstPause)(handlerResult, () => {
            finishLock = setupAsyncLocks(cache, futureCache, arg);
          });
        } else {
          value2 = handlerResult;
        }
        updateFunctionCache(callCache, cache, arg, value2);
        if (finishLock) {
          futureCache.delete(arg);
          finishLock.release(value2);
        }
        return value2;
      };
    }
    function* getCachedValue(cache, arg, data3) {
      const cachedValue = cache.get(arg);
      if (cachedValue) {
        for (const {
          value: value2,
          valid: valid2
        } of cachedValue) {
          if (yield* valid2(data3))
            return {
              valid: true,
              value: value2
            };
        }
      }
      return {
        valid: false,
        value: null
      };
    }
    function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data3) {
      const cached = yield* getCachedValue(callCache, arg, data3);
      if (cached.valid) {
        return cached;
      }
      if (asyncContext) {
        const cached2 = yield* getCachedValue(futureCache, arg, data3);
        if (cached2.valid) {
          const value2 = yield* (0, _async.waitFor)(cached2.value.promise);
          return {
            valid: true,
            value: value2
          };
        }
      }
      return {
        valid: false,
        value: null
      };
    }
    function setupAsyncLocks(config, futureCache, arg) {
      const finishLock = new Lock();
      updateFunctionCache(futureCache, config, arg, finishLock);
      return finishLock;
    }
    function updateFunctionCache(cache, config, arg, value2) {
      if (!config.configured())
        config.forever();
      let cachedValue = cache.get(arg);
      config.deactivate();
      switch (config.mode()) {
        case "forever":
          cachedValue = [{
            value: value2,
            valid: genTrue
          }];
          cache.set(arg, cachedValue);
          break;
        case "invalidate":
          cachedValue = [{
            value: value2,
            valid: config.validator()
          }];
          cache.set(arg, cachedValue);
          break;
        case "valid":
          if (cachedValue) {
            cachedValue.push({
              value: value2,
              valid: config.validator()
            });
          } else {
            cachedValue = [{
              value: value2,
              valid: config.validator()
            }];
            cache.set(arg, cachedValue);
          }
      }
    }
    var CacheConfigurator = class {
      constructor(data3) {
        this._active = true;
        this._never = false;
        this._forever = false;
        this._invalidate = false;
        this._configured = false;
        this._pairs = [];
        this._data = void 0;
        this._data = data3;
      }
      simple() {
        return makeSimpleConfigurator(this);
      }
      mode() {
        if (this._never)
          return "never";
        if (this._forever)
          return "forever";
        if (this._invalidate)
          return "invalidate";
        return "valid";
      }
      forever() {
        if (!this._active) {
          throw new Error("Cannot change caching after evaluation has completed.");
        }
        if (this._never) {
          throw new Error("Caching has already been configured with .never()");
        }
        this._forever = true;
        this._configured = true;
      }
      never() {
        if (!this._active) {
          throw new Error("Cannot change caching after evaluation has completed.");
        }
        if (this._forever) {
          throw new Error("Caching has already been configured with .forever()");
        }
        this._never = true;
        this._configured = true;
      }
      using(handler) {
        if (!this._active) {
          throw new Error("Cannot change caching after evaluation has completed.");
        }
        if (this._never || this._forever) {
          throw new Error("Caching has already been configured with .never or .forever()");
        }
        this._configured = true;
        const key2 = handler(this._data);
        const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
        if ((0, _async.isThenable)(key2)) {
          return key2.then((key3) => {
            this._pairs.push([key3, fn]);
            return key3;
          });
        }
        this._pairs.push([key2, fn]);
        return key2;
      }
      invalidate(handler) {
        this._invalidate = true;
        return this.using(handler);
      }
      validator() {
        const pairs = this._pairs;
        return function* (data3) {
          for (const [key2, fn] of pairs) {
            if (key2 !== (yield* fn(data3)))
              return false;
          }
          return true;
        };
      }
      deactivate() {
        this._active = false;
      }
      configured() {
        return this._configured;
      }
    };
    function makeSimpleConfigurator(cache) {
      function cacheFn(val) {
        if (typeof val === "boolean") {
          if (val)
            cache.forever();
          else
            cache.never();
          return;
        }
        return cache.using(() => assertSimpleType(val()));
      }
      cacheFn.forever = () => cache.forever();
      cacheFn.never = () => cache.never();
      cacheFn.using = (cb) => cache.using(() => assertSimpleType(cb()));
      cacheFn.invalidate = (cb) => cache.invalidate(() => assertSimpleType(cb()));
      return cacheFn;
    }
    function assertSimpleType(value2) {
      if ((0, _async.isThenable)(value2)) {
        throw new Error(`You appear to be using an async cache handler, which your current version of Babel does not support. We may add support for this in the future, but if you're on the most recent version of @babel/core and still seeing this error, then you'll need to synchronously handle your caching logic.`);
      }
      if (value2 != null && typeof value2 !== "string" && typeof value2 !== "boolean" && typeof value2 !== "number") {
        throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
      }
      return value2;
    }
    var Lock = class {
      constructor() {
        this.released = false;
        this.promise = void 0;
        this._resolve = void 0;
        this.promise = new Promise((resolve) => {
          this._resolve = resolve;
        });
      }
      release(value2) {
        this.released = true;
        this._resolve(value2);
      }
    };
  }
});

// node_modules/@babel/core/lib/gensync-utils/fs.js
var require_fs = __commonJS({
  "node_modules/@babel/core/lib/gensync-utils/fs.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.stat = exports.readFile = void 0;
    function _fs() {
      const data3 = require("fs");
      _fs = function() {
        return data3;
      };
      return data3;
    }
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var readFile = _gensync()({
      sync: _fs().readFileSync,
      errback: _fs().readFile
    });
    exports.readFile = readFile;
    var stat = _gensync()({
      sync: _fs().statSync,
      errback: _fs().stat
    });
    exports.stat = stat;
  }
});

// node_modules/@babel/core/lib/config/files/utils.js
var require_utils2 = __commonJS({
  "node_modules/@babel/core/lib/config/files/utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.makeStaticFileCache = makeStaticFileCache;
    var _caching = require_caching();
    var fs = require_fs();
    function _fs2() {
      const data3 = require("fs");
      _fs2 = function() {
        return data3;
      };
      return data3;
    }
    function makeStaticFileCache(fn) {
      return (0, _caching.makeStrongCache)(function* (filepath, cache) {
        const cached = cache.invalidate(() => fileMtime(filepath));
        if (cached === null) {
          return null;
        }
        return fn(filepath, yield* fs.readFile(filepath, "utf8"));
      });
    }
    function fileMtime(filepath) {
      if (!_fs2().existsSync(filepath))
        return null;
      try {
        return +_fs2().statSync(filepath).mtime;
      } catch (e) {
        if (e.code !== "ENOENT" && e.code !== "ENOTDIR")
          throw e;
      }
      return null;
    }
  }
});

// node_modules/@babel/core/lib/errors/rewrite-stack-trace.js
var require_rewrite_stack_trace = __commonJS({
  "node_modules/@babel/core/lib/errors/rewrite-stack-trace.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.beginHiddenCallStack = beginHiddenCallStack;
    exports.endHiddenCallStack = endHiddenCallStack;
    exports.expectedError = expectedError;
    exports.injectVirtualStackFrame = injectVirtualStackFrame;
    var ErrorToString = Function.call.bind(Error.prototype.toString);
    var SUPPORTED = !!Error.captureStackTrace;
    var START_HIDING = "startHiding - secret - don't use this - v1";
    var STOP_HIDING = "stopHiding - secret - don't use this - v1";
    var expectedErrors = /* @__PURE__ */ new WeakSet();
    var virtualFrames = /* @__PURE__ */ new WeakMap();
    function CallSite(filename) {
      return /* @__PURE__ */ Object.create({
        isNative: () => false,
        isConstructor: () => false,
        isToplevel: () => true,
        getFileName: () => filename,
        getLineNumber: () => void 0,
        getColumnNumber: () => void 0,
        getFunctionName: () => void 0,
        getMethodName: () => void 0,
        getTypeName: () => void 0,
        toString: () => filename
      });
    }
    function injectVirtualStackFrame(error, filename) {
      if (!SUPPORTED)
        return;
      let frames = virtualFrames.get(error);
      if (!frames)
        virtualFrames.set(error, frames = []);
      frames.push(CallSite(filename));
      return error;
    }
    function expectedError(error) {
      if (!SUPPORTED)
        return;
      expectedErrors.add(error);
      return error;
    }
    function beginHiddenCallStack(fn) {
      if (!SUPPORTED)
        return fn;
      return Object.defineProperty(function(...args) {
        setupPrepareStackTrace();
        return fn(...args);
      }, "name", {
        value: STOP_HIDING
      });
    }
    function endHiddenCallStack(fn) {
      if (!SUPPORTED)
        return fn;
      return Object.defineProperty(function(...args) {
        return fn(...args);
      }, "name", {
        value: START_HIDING
      });
    }
    function setupPrepareStackTrace() {
      setupPrepareStackTrace = () => {
      };
      const {
        prepareStackTrace = defaultPrepareStackTrace
      } = Error;
      const MIN_STACK_TRACE_LIMIT = 50;
      Error.stackTraceLimit && (Error.stackTraceLimit = Math.max(Error.stackTraceLimit, MIN_STACK_TRACE_LIMIT));
      Error.prepareStackTrace = function stackTraceRewriter(err, trace) {
        let newTrace = [];
        const isExpected = expectedErrors.has(err);
        let status = isExpected ? "hiding" : "unknown";
        for (let i = 0; i < trace.length; i++) {
          const name2 = trace[i].getFunctionName();
          if (name2 === START_HIDING) {
            status = "hiding";
          } else if (name2 === STOP_HIDING) {
            if (status === "hiding") {
              status = "showing";
              if (virtualFrames.has(err)) {
                newTrace.unshift(...virtualFrames.get(err));
              }
            } else if (status === "unknown") {
              newTrace = trace;
              break;
            }
          } else if (status !== "hiding") {
            newTrace.push(trace[i]);
          }
        }
        return prepareStackTrace(err, newTrace);
      };
    }
    function defaultPrepareStackTrace(err, trace) {
      if (trace.length === 0)
        return ErrorToString(err);
      return `${ErrorToString(err)}
    at ${trace.join("\n    at ")}`;
    }
  }
});

// node_modules/@babel/core/lib/errors/config-error.js
var require_config_error = __commonJS({
  "node_modules/@babel/core/lib/errors/config-error.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var ConfigError = class extends Error {
      constructor(message, filename) {
        super(message);
        (0, _rewriteStackTrace.expectedError)(this);
        if (filename)
          (0, _rewriteStackTrace.injectVirtualStackFrame)(this, filename);
      }
    };
    exports.default = ConfigError;
  }
});

// node_modules/@babel/core/lib/config/files/package.js
var require_package = __commonJS({
  "node_modules/@babel/core/lib/config/files/package.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.findPackageData = findPackageData;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    var _utils = require_utils2();
    var _configError = require_config_error();
    var PACKAGE_FILENAME = "package.json";
    var readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content3) => {
      let options;
      try {
        options = JSON.parse(content3);
      } catch (err) {
        throw new _configError.default(`Error while parsing JSON - ${err.message}`, filepath);
      }
      if (!options)
        throw new Error(`${filepath}: No config detected`);
      if (typeof options !== "object") {
        throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
      }
      if (Array.isArray(options)) {
        throw new _configError.default(`Expected config object but found array`, filepath);
      }
      return {
        filepath,
        dirname: _path().dirname(filepath),
        options
      };
    });
    function* findPackageData(filepath) {
      let pkg = null;
      const directories = [];
      let isPackage = true;
      let dirname = _path().dirname(filepath);
      while (!pkg && _path().basename(dirname) !== "node_modules") {
        directories.push(dirname);
        pkg = yield* readConfigPackage(_path().join(dirname, PACKAGE_FILENAME));
        const nextLoc = _path().dirname(dirname);
        if (dirname === nextLoc) {
          isPackage = false;
          break;
        }
        dirname = nextLoc;
      }
      return {
        filepath,
        directories,
        pkg,
        isPackage
      };
    }
  }
});

// node_modules/json5/dist/index.mjs
var dist_exports = {};
__export(dist_exports, {
  default: () => dist_default
});
function internalize(holder, name2, reviver) {
  const value2 = holder[name2];
  if (value2 != null && typeof value2 === "object") {
    if (Array.isArray(value2)) {
      for (let i = 0; i < value2.length; i++) {
        const key2 = String(i);
        const replacement = internalize(value2, key2, reviver);
        if (replacement === void 0) {
          delete value2[key2];
        } else {
          Object.defineProperty(value2, key2, {
            value: replacement,
            writable: true,
            enumerable: true,
            configurable: true
          });
        }
      }
    } else {
      for (const key2 in value2) {
        const replacement = internalize(value2, key2, reviver);
        if (replacement === void 0) {
          delete value2[key2];
        } else {
          Object.defineProperty(value2, key2, {
            value: replacement,
            writable: true,
            enumerable: true,
            configurable: true
          });
        }
      }
    }
  }
  return reviver.call(holder, name2, value2);
}
function lex() {
  lexState = "default";
  buffer2 = "";
  doubleQuote = false;
  sign = 1;
  for (; ; ) {
    c = peek();
    const token2 = lexStates[lexState]();
    if (token2) {
      return token2;
    }
  }
}
function peek() {
  if (source[pos]) {
    return String.fromCodePoint(source.codePointAt(pos));
  }
}
function read() {
  const c2 = peek();
  if (c2 === "\n") {
    line++;
    column = 0;
  } else if (c2) {
    column += c2.length;
  } else {
    column++;
  }
  if (c2) {
    pos += c2.length;
  }
  return c2;
}
function newToken(type, value2) {
  return {
    type,
    value: value2,
    line,
    column
  };
}
function literal3(s) {
  for (const c2 of s) {
    const p = peek();
    if (p !== c2) {
      throw invalidChar(read());
    }
    read();
  }
}
function escape2() {
  const c2 = peek();
  switch (c2) {
    case "b":
      read();
      return "\b";
    case "f":
      read();
      return "\f";
    case "n":
      read();
      return "\n";
    case "r":
      read();
      return "\r";
    case "t":
      read();
      return "	";
    case "v":
      read();
      return "\v";
    case "0":
      read();
      if (util.isDigit(peek())) {
        throw invalidChar(read());
      }
      return "\0";
    case "x":
      read();
      return hexEscape();
    case "u":
      read();
      return unicodeEscape();
    case "\n":
    case "\u2028":
    case "\u2029":
      read();
      return "";
    case "\r":
      read();
      if (peek() === "\n") {
        read();
      }
      return "";
    case "1":
    case "2":
    case "3":
    case "4":
    case "5":
    case "6":
    case "7":
    case "8":
    case "9":
      throw invalidChar(read());
    case void 0:
      throw invalidChar(read());
  }
  return read();
}
function hexEscape() {
  let buffer3 = "";
  let c2 = peek();
  if (!util.isHexDigit(c2)) {
    throw invalidChar(read());
  }
  buffer3 += read();
  c2 = peek();
  if (!util.isHexDigit(c2)) {
    throw invalidChar(read());
  }
  buffer3 += read();
  return String.fromCodePoint(parseInt(buffer3, 16));
}
function unicodeEscape() {
  let buffer3 = "";
  let count = 4;
  while (count-- > 0) {
    const c2 = peek();
    if (!util.isHexDigit(c2)) {
      throw invalidChar(read());
    }
    buffer3 += read();
  }
  return String.fromCodePoint(parseInt(buffer3, 16));
}
function push2() {
  let value2;
  switch (token.type) {
    case "punctuator":
      switch (token.value) {
        case "{":
          value2 = {};
          break;
        case "[":
          value2 = [];
          break;
      }
      break;
    case "null":
    case "boolean":
    case "numeric":
    case "string":
      value2 = token.value;
      break;
  }
  if (root3 === void 0) {
    root3 = value2;
  } else {
    const parent = stack[stack.length - 1];
    if (Array.isArray(parent)) {
      parent.push(value2);
    } else {
      Object.defineProperty(parent, key, {
        value: value2,
        writable: true,
        enumerable: true,
        configurable: true
      });
    }
  }
  if (value2 !== null && typeof value2 === "object") {
    stack.push(value2);
    if (Array.isArray(value2)) {
      parseState = "beforeArrayValue";
    } else {
      parseState = "beforePropertyName";
    }
  } else {
    const current3 = stack[stack.length - 1];
    if (current3 == null) {
      parseState = "end";
    } else if (Array.isArray(current3)) {
      parseState = "afterArrayValue";
    } else {
      parseState = "afterPropertyValue";
    }
  }
}
function pop() {
  stack.pop();
  const current3 = stack[stack.length - 1];
  if (current3 == null) {
    parseState = "end";
  } else if (Array.isArray(current3)) {
    parseState = "afterArrayValue";
  } else {
    parseState = "afterPropertyValue";
  }
}
function invalidChar(c2) {
  if (c2 === void 0) {
    return syntaxError(`JSON5: invalid end of input at ${line}:${column}`);
  }
  return syntaxError(`JSON5: invalid character '${formatChar(c2)}' at ${line}:${column}`);
}
function invalidEOF() {
  return syntaxError(`JSON5: invalid end of input at ${line}:${column}`);
}
function invalidIdentifier() {
  column -= 5;
  return syntaxError(`JSON5: invalid identifier character at ${line}:${column}`);
}
function separatorChar(c2) {
  console.warn(`JSON5: '${formatChar(c2)}' in strings is not valid ECMAScript; consider escaping`);
}
function formatChar(c2) {
  const replacements = {
    "'": "\\'",
    '"': '\\"',
    "\\": "\\\\",
    "\b": "\\b",
    "\f": "\\f",
    "\n": "\\n",
    "\r": "\\r",
    "	": "\\t",
    "\v": "\\v",
    "\0": "\\0",
    "\u2028": "\\u2028",
    "\u2029": "\\u2029"
  };
  if (replacements[c2]) {
    return replacements[c2];
  }
  if (c2 < " ") {
    const hexString = c2.charCodeAt(0).toString(16);
    return "\\x" + ("00" + hexString).substring(hexString.length);
  }
  return c2;
}
function syntaxError(message) {
  const err = new SyntaxError(message);
  err.lineNumber = line;
  err.columnNumber = column;
  return err;
}
var Space_Separator, ID_Start, ID_Continue, unicode, util, source, parseState, stack, pos, line, column, token, key, root3, parse7, lexState, buffer2, doubleQuote, sign, c, lexStates, parseStates, stringify4, JSON5, lib, dist_default;
var init_dist = __esm({
  "node_modules/json5/dist/index.mjs"() {
    Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
    ID_Start = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/;
    ID_Continue = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/;
    unicode = {
      Space_Separator,
      ID_Start,
      ID_Continue
    };
    util = {
      isSpaceSeparator(c2) {
        return typeof c2 === "string" && unicode.Space_Separator.test(c2);
      },
      isIdStartChar(c2) {
        return typeof c2 === "string" && (c2 >= "a" && c2 <= "z" || c2 >= "A" && c2 <= "Z" || c2 === "$" || c2 === "_" || unicode.ID_Start.test(c2));
      },
      isIdContinueChar(c2) {
        return typeof c2 === "string" && (c2 >= "a" && c2 <= "z" || c2 >= "A" && c2 <= "Z" || c2 >= "0" && c2 <= "9" || c2 === "$" || c2 === "_" || c2 === "\u200C" || c2 === "\u200D" || unicode.ID_Continue.test(c2));
      },
      isDigit(c2) {
        return typeof c2 === "string" && /[0-9]/.test(c2);
      },
      isHexDigit(c2) {
        return typeof c2 === "string" && /[0-9A-Fa-f]/.test(c2);
      }
    };
    parse7 = function parse8(text5, reviver) {
      source = String(text5);
      parseState = "start";
      stack = [];
      pos = 0;
      line = 1;
      column = 0;
      token = void 0;
      key = void 0;
      root3 = void 0;
      do {
        token = lex();
        parseStates[parseState]();
      } while (token.type !== "eof");
      if (typeof reviver === "function") {
        return internalize({ "": root3 }, "", reviver);
      }
      return root3;
    };
    lexStates = {
      default() {
        switch (c) {
          case "	":
          case "\v":
          case "\f":
          case " ":
          case "\xA0":
          case "\uFEFF":
          case "\n":
          case "\r":
          case "\u2028":
          case "\u2029":
            read();
            return;
          case "/":
            read();
            lexState = "comment";
            return;
          case void 0:
            read();
            return newToken("eof");
        }
        if (util.isSpaceSeparator(c)) {
          read();
          return;
        }
        return lexStates[parseState]();
      },
      comment() {
        switch (c) {
          case "*":
            read();
            lexState = "multiLineComment";
            return;
          case "/":
            read();
            lexState = "singleLineComment";
            return;
        }
        throw invalidChar(read());
      },
      multiLineComment() {
        switch (c) {
          case "*":
            read();
            lexState = "multiLineCommentAsterisk";
            return;
          case void 0:
            throw invalidChar(read());
        }
        read();
      },
      multiLineCommentAsterisk() {
        switch (c) {
          case "*":
            read();
            return;
          case "/":
            read();
            lexState = "default";
            return;
          case void 0:
            throw invalidChar(read());
        }
        read();
        lexState = "multiLineComment";
      },
      singleLineComment() {
        switch (c) {
          case "\n":
          case "\r":
          case "\u2028":
          case "\u2029":
            read();
            lexState = "default";
            return;
          case void 0:
            read();
            return newToken("eof");
        }
        read();
      },
      value() {
        switch (c) {
          case "{":
          case "[":
            return newToken("punctuator", read());
          case "n":
            read();
            literal3("ull");
            return newToken("null", null);
          case "t":
            read();
            literal3("rue");
            return newToken("boolean", true);
          case "f":
            read();
            literal3("alse");
            return newToken("boolean", false);
          case "-":
          case "+":
            if (read() === "-") {
              sign = -1;
            }
            lexState = "sign";
            return;
          case ".":
            buffer2 = read();
            lexState = "decimalPointLeading";
            return;
          case "0":
            buffer2 = read();
            lexState = "zero";
            return;
          case "1":
          case "2":
          case "3":
          case "4":
          case "5":
          case "6":
          case "7":
          case "8":
          case "9":
            buffer2 = read();
            lexState = "decimalInteger";
            return;
          case "I":
            read();
            literal3("nfinity");
            return newToken("numeric", Infinity);
          case "N":
            read();
            literal3("aN");
            return newToken("numeric", NaN);
          case '"':
          case "'":
            doubleQuote = read() === '"';
            buffer2 = "";
            lexState = "string";
            return;
        }
        throw invalidChar(read());
      },
      identifierNameStartEscape() {
        if (c !== "u") {
          throw invalidChar(read());
        }
        read();
        const u = unicodeEscape();
        switch (u) {
          case "$":
          case "_":
            break;
          default:
            if (!util.isIdStartChar(u)) {
              throw invalidIdentifier();
            }
            break;
        }
        buffer2 += u;
        lexState = "identifierName";
      },
      identifierName() {
        switch (c) {
          case "$":
          case "_":
          case "\u200C":
          case "\u200D":
            buffer2 += read();
            return;
          case "\\":
            read();
            lexState = "identifierNameEscape";
            return;
        }
        if (util.isIdContinueChar(c)) {
          buffer2 += read();
          return;
        }
        return newToken("identifier", buffer2);
      },
      identifierNameEscape() {
        if (c !== "u") {
          throw invalidChar(read());
        }
        read();
        const u = unicodeEscape();
        switch (u) {
          case "$":
          case "_":
          case "\u200C":
          case "\u200D":
            break;
          default:
            if (!util.isIdContinueChar(u)) {
              throw invalidIdentifier();
            }
            break;
        }
        buffer2 += u;
        lexState = "identifierName";
      },
      sign() {
        switch (c) {
          case ".":
            buffer2 = read();
            lexState = "decimalPointLeading";
            return;
          case "0":
            buffer2 = read();
            lexState = "zero";
            return;
          case "1":
          case "2":
          case "3":
          case "4":
          case "5":
          case "6":
          case "7":
          case "8":
          case "9":
            buffer2 = read();
            lexState = "decimalInteger";
            return;
          case "I":
            read();
            literal3("nfinity");
            return newToken("numeric", sign * Infinity);
          case "N":
            read();
            literal3("aN");
            return newToken("numeric", NaN);
        }
        throw invalidChar(read());
      },
      zero() {
        switch (c) {
          case ".":
            buffer2 += read();
            lexState = "decimalPoint";
            return;
          case "e":
          case "E":
            buffer2 += read();
            lexState = "decimalExponent";
            return;
          case "x":
          case "X":
            buffer2 += read();
            lexState = "hexadecimal";
            return;
        }
        return newToken("numeric", sign * 0);
      },
      decimalInteger() {
        switch (c) {
          case ".":
            buffer2 += read();
            lexState = "decimalPoint";
            return;
          case "e":
          case "E":
            buffer2 += read();
            lexState = "decimalExponent";
            return;
        }
        if (util.isDigit(c)) {
          buffer2 += read();
          return;
        }
        return newToken("numeric", sign * Number(buffer2));
      },
      decimalPointLeading() {
        if (util.isDigit(c)) {
          buffer2 += read();
          lexState = "decimalFraction";
          return;
        }
        throw invalidChar(read());
      },
      decimalPoint() {
        switch (c) {
          case "e":
          case "E":
            buffer2 += read();
            lexState = "decimalExponent";
            return;
        }
        if (util.isDigit(c)) {
          buffer2 += read();
          lexState = "decimalFraction";
          return;
        }
        return newToken("numeric", sign * Number(buffer2));
      },
      decimalFraction() {
        switch (c) {
          case "e":
          case "E":
            buffer2 += read();
            lexState = "decimalExponent";
            return;
        }
        if (util.isDigit(c)) {
          buffer2 += read();
          return;
        }
        return newToken("numeric", sign * Number(buffer2));
      },
      decimalExponent() {
        switch (c) {
          case "+":
          case "-":
            buffer2 += read();
            lexState = "decimalExponentSign";
            return;
        }
        if (util.isDigit(c)) {
          buffer2 += read();
          lexState = "decimalExponentInteger";
          return;
        }
        throw invalidChar(read());
      },
      decimalExponentSign() {
        if (util.isDigit(c)) {
          buffer2 += read();
          lexState = "decimalExponentInteger";
          return;
        }
        throw invalidChar(read());
      },
      decimalExponentInteger() {
        if (util.isDigit(c)) {
          buffer2 += read();
          return;
        }
        return newToken("numeric", sign * Number(buffer2));
      },
      hexadecimal() {
        if (util.isHexDigit(c)) {
          buffer2 += read();
          lexState = "hexadecimalInteger";
          return;
        }
        throw invalidChar(read());
      },
      hexadecimalInteger() {
        if (util.isHexDigit(c)) {
          buffer2 += read();
          return;
        }
        return newToken("numeric", sign * Number(buffer2));
      },
      string() {
        switch (c) {
          case "\\":
            read();
            buffer2 += escape2();
            return;
          case '"':
            if (doubleQuote) {
              read();
              return newToken("string", buffer2);
            }
            buffer2 += read();
            return;
          case "'":
            if (!doubleQuote) {
              read();
              return newToken("string", buffer2);
            }
            buffer2 += read();
            return;
          case "\n":
          case "\r":
            throw invalidChar(read());
          case "\u2028":
          case "\u2029":
            separatorChar(c);
            break;
          case void 0:
            throw invalidChar(read());
        }
        buffer2 += read();
      },
      start() {
        switch (c) {
          case "{":
          case "[":
            return newToken("punctuator", read());
        }
        lexState = "value";
      },
      beforePropertyName() {
        switch (c) {
          case "$":
          case "_":
            buffer2 = read();
            lexState = "identifierName";
            return;
          case "\\":
            read();
            lexState = "identifierNameStartEscape";
            return;
          case "}":
            return newToken("punctuator", read());
          case '"':
          case "'":
            doubleQuote = read() === '"';
            lexState = "string";
            return;
        }
        if (util.isIdStartChar(c)) {
          buffer2 += read();
          lexState = "identifierName";
          return;
        }
        throw invalidChar(read());
      },
      afterPropertyName() {
        if (c === ":") {
          return newToken("punctuator", read());
        }
        throw invalidChar(read());
      },
      beforePropertyValue() {
        lexState = "value";
      },
      afterPropertyValue() {
        switch (c) {
          case ",":
          case "}":
            return newToken("punctuator", read());
        }
        throw invalidChar(read());
      },
      beforeArrayValue() {
        if (c === "]") {
          return newToken("punctuator", read());
        }
        lexState = "value";
      },
      afterArrayValue() {
        switch (c) {
          case ",":
          case "]":
            return newToken("punctuator", read());
        }
        throw invalidChar(read());
      },
      end() {
        throw invalidChar(read());
      }
    };
    parseStates = {
      start() {
        if (token.type === "eof") {
          throw invalidEOF();
        }
        push2();
      },
      beforePropertyName() {
        switch (token.type) {
          case "identifier":
          case "string":
            key = token.value;
            parseState = "afterPropertyName";
            return;
          case "punctuator":
            pop();
            return;
          case "eof":
            throw invalidEOF();
        }
      },
      afterPropertyName() {
        if (token.type === "eof") {
          throw invalidEOF();
        }
        parseState = "beforePropertyValue";
      },
      beforePropertyValue() {
        if (token.type === "eof") {
          throw invalidEOF();
        }
        push2();
      },
      beforeArrayValue() {
        if (token.type === "eof") {
          throw invalidEOF();
        }
        if (token.type === "punctuator" && token.value === "]") {
          pop();
          return;
        }
        push2();
      },
      afterPropertyValue() {
        if (token.type === "eof") {
          throw invalidEOF();
        }
        switch (token.value) {
          case ",":
            parseState = "beforePropertyName";
            return;
          case "}":
            pop();
        }
      },
      afterArrayValue() {
        if (token.type === "eof") {
          throw invalidEOF();
        }
        switch (token.value) {
          case ",":
            parseState = "beforeArrayValue";
            return;
          case "]":
            pop();
        }
      },
      end() {
      }
    };
    stringify4 = function stringify5(value2, replacer, space2) {
      const stack2 = [];
      let indent = "";
      let propertyList;
      let replacerFunc;
      let gap = "";
      let quote;
      if (replacer != null && typeof replacer === "object" && !Array.isArray(replacer)) {
        space2 = replacer.space;
        quote = replacer.quote;
        replacer = replacer.replacer;
      }
      if (typeof replacer === "function") {
        replacerFunc = replacer;
      } else if (Array.isArray(replacer)) {
        propertyList = [];
        for (const v of replacer) {
          let item;
          if (typeof v === "string") {
            item = v;
          } else if (typeof v === "number" || v instanceof String || v instanceof Number) {
            item = String(v);
          }
          if (item !== void 0 && propertyList.indexOf(item) < 0) {
            propertyList.push(item);
          }
        }
      }
      if (space2 instanceof Number) {
        space2 = Number(space2);
      } else if (space2 instanceof String) {
        space2 = String(space2);
      }
      if (typeof space2 === "number") {
        if (space2 > 0) {
          space2 = Math.min(10, Math.floor(space2));
          gap = "          ".substr(0, space2);
        }
      } else if (typeof space2 === "string") {
        gap = space2.substr(0, 10);
      }
      return serializeProperty("", { "": value2 });
      function serializeProperty(key2, holder) {
        let value3 = holder[key2];
        if (value3 != null) {
          if (typeof value3.toJSON5 === "function") {
            value3 = value3.toJSON5(key2);
          } else if (typeof value3.toJSON === "function") {
            value3 = value3.toJSON(key2);
          }
        }
        if (replacerFunc) {
          value3 = replacerFunc.call(holder, key2, value3);
        }
        if (value3 instanceof Number) {
          value3 = Number(value3);
        } else if (value3 instanceof String) {
          value3 = String(value3);
        } else if (value3 instanceof Boolean) {
          value3 = value3.valueOf();
        }
        switch (value3) {
          case null:
            return "null";
          case true:
            return "true";
          case false:
            return "false";
        }
        if (typeof value3 === "string") {
          return quoteString(value3, false);
        }
        if (typeof value3 === "number") {
          return String(value3);
        }
        if (typeof value3 === "object") {
          return Array.isArray(value3) ? serializeArray(value3) : serializeObject(value3);
        }
        return void 0;
      }
      function quoteString(value3) {
        const quotes = {
          "'": 0.1,
          '"': 0.2
        };
        const replacements = {
          "'": "\\'",
          '"': '\\"',
          "\\": "\\\\",
          "\b": "\\b",
          "\f": "\\f",
          "\n": "\\n",
          "\r": "\\r",
          "	": "\\t",
          "\v": "\\v",
          "\0": "\\0",
          "\u2028": "\\u2028",
          "\u2029": "\\u2029"
        };
        let product = "";
        for (let i = 0; i < value3.length; i++) {
          const c2 = value3[i];
          switch (c2) {
            case "'":
            case '"':
              quotes[c2]++;
              product += c2;
              continue;
            case "\0":
              if (util.isDigit(value3[i + 1])) {
                product += "\\x00";
                continue;
              }
          }
          if (replacements[c2]) {
            product += replacements[c2];
            continue;
          }
          if (c2 < " ") {
            let hexString = c2.charCodeAt(0).toString(16);
            product += "\\x" + ("00" + hexString).substring(hexString.length);
            continue;
          }
          product += c2;
        }
        const quoteChar = quote || Object.keys(quotes).reduce((a, b) => quotes[a] < quotes[b] ? a : b);
        product = product.replace(new RegExp(quoteChar, "g"), replacements[quoteChar]);
        return quoteChar + product + quoteChar;
      }
      function serializeObject(value3) {
        if (stack2.indexOf(value3) >= 0) {
          throw TypeError("Converting circular structure to JSON5");
        }
        stack2.push(value3);
        let stepback = indent;
        indent = indent + gap;
        let keys2 = propertyList || Object.keys(value3);
        let partial = [];
        for (const key2 of keys2) {
          const propertyString = serializeProperty(key2, value3);
          if (propertyString !== void 0) {
            let member = serializeKey(key2) + ":";
            if (gap !== "") {
              member += " ";
            }
            member += propertyString;
            partial.push(member);
          }
        }
        let final;
        if (partial.length === 0) {
          final = "{}";
        } else {
          let properties;
          if (gap === "") {
            properties = partial.join(",");
            final = "{" + properties + "}";
          } else {
            let separator = ",\n" + indent;
            properties = partial.join(separator);
            final = "{\n" + indent + properties + ",\n" + stepback + "}";
          }
        }
        stack2.pop();
        indent = stepback;
        return final;
      }
      function serializeKey(key2) {
        if (key2.length === 0) {
          return quoteString(key2, true);
        }
        const firstChar = String.fromCodePoint(key2.codePointAt(0));
        if (!util.isIdStartChar(firstChar)) {
          return quoteString(key2, true);
        }
        for (let i = firstChar.length; i < key2.length; i++) {
          if (!util.isIdContinueChar(String.fromCodePoint(key2.codePointAt(i)))) {
            return quoteString(key2, true);
          }
        }
        return key2;
      }
      function serializeArray(value3) {
        if (stack2.indexOf(value3) >= 0) {
          throw TypeError("Converting circular structure to JSON5");
        }
        stack2.push(value3);
        let stepback = indent;
        indent = indent + gap;
        let partial = [];
        for (let i = 0; i < value3.length; i++) {
          const propertyString = serializeProperty(String(i), value3);
          partial.push(propertyString !== void 0 ? propertyString : "null");
        }
        let final;
        if (partial.length === 0) {
          final = "[]";
        } else {
          if (gap === "") {
            let properties = partial.join(",");
            final = "[" + properties + "]";
          } else {
            let separator = ",\n" + indent;
            let properties = partial.join(separator);
            final = "[\n" + indent + properties + ",\n" + stepback + "]";
          }
        }
        stack2.pop();
        indent = stepback;
        return final;
      }
    };
    JSON5 = {
      parse: parse7,
      stringify: stringify4
    };
    lib = JSON5;
    dist_default = lib;
  }
});

// node_modules/@babel/core/lib/config/helpers/config-api.js
var require_config_api = __commonJS({
  "node_modules/@babel/core/lib/config/helpers/config-api.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.makeConfigAPI = makeConfigAPI;
    exports.makePluginAPI = makePluginAPI;
    exports.makePresetAPI = makePresetAPI;
    function _semver() {
      const data3 = require_semver();
      _semver = function() {
        return data3;
      };
      return data3;
    }
    var _ = require_lib32();
    var _caching = require_caching();
    function makeConfigAPI(cache) {
      const env = (value2) => cache.using((data3) => {
        if (typeof value2 === "undefined")
          return data3.envName;
        if (typeof value2 === "function") {
          return (0, _caching.assertSimpleType)(value2(data3.envName));
        }
        return (Array.isArray(value2) ? value2 : [value2]).some((entry) => {
          if (typeof entry !== "string") {
            throw new Error("Unexpected non-string value");
          }
          return entry === data3.envName;
        });
      });
      const caller = (cb) => cache.using((data3) => (0, _caching.assertSimpleType)(cb(data3.caller)));
      return {
        version: _.version,
        cache: cache.simple(),
        env,
        async: () => false,
        caller,
        assertVersion
      };
    }
    function makePresetAPI(cache, externalDependencies) {
      const targets = () => JSON.parse(cache.using((data3) => JSON.stringify(data3.targets)));
      const addExternalDependency = (ref3) => {
        externalDependencies.push(ref3);
      };
      return Object.assign({}, makeConfigAPI(cache), {
        targets,
        addExternalDependency
      });
    }
    function makePluginAPI(cache, externalDependencies) {
      const assumption = (name2) => cache.using((data3) => data3.assumptions[name2]);
      return Object.assign({}, makePresetAPI(cache, externalDependencies), {
        assumption
      });
    }
    function assertVersion(range) {
      if (typeof range === "number") {
        if (!Number.isInteger(range)) {
          throw new Error("Expected string or integer value.");
        }
        range = `^${range}.0.0-0`;
      }
      if (typeof range !== "string") {
        throw new Error("Expected string or integer value.");
      }
      if (_semver().satisfies(_.version, range))
        return;
      const limit = Error.stackTraceLimit;
      if (typeof limit === "number" && limit < 25) {
        Error.stackTraceLimit = 25;
      }
      const err = new Error(`Requires Babel "${range}", but was loaded with "${_.version}". If you are sure you have a compatible version of @babel/core, it is likely that something in your build process is loading the wrong version. Inspect the stack trace of this error to look for the first entry that doesn't mention "@babel/core" or "babel-core" to see what is calling Babel.`);
      if (typeof limit === "number") {
        Error.stackTraceLimit = limit;
      }
      throw Object.assign(err, {
        code: "BABEL_VERSION_UNSUPPORTED",
        version: _.version,
        range
      });
    }
  }
});

// node_modules/@babel/core/lib/config/helpers/deep-array.js
var require_deep_array = __commonJS({
  "node_modules/@babel/core/lib/config/helpers/deep-array.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.finalize = finalize;
    exports.flattenToSet = flattenToSet;
    function finalize(deepArr) {
      return Object.freeze(deepArr);
    }
    function flattenToSet(arr) {
      const result = /* @__PURE__ */ new Set();
      const stack2 = [arr];
      while (stack2.length > 0) {
        for (const el of stack2.pop()) {
          if (Array.isArray(el))
            stack2.push(el);
          else
            result.add(el);
        }
      }
      return result;
    }
  }
});

// node_modules/@babel/core/lib/config/plugin.js
var require_plugin = __commonJS({
  "node_modules/@babel/core/lib/config/plugin.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _deepArray = require_deep_array();
    var Plugin = class {
      constructor(plugin2, options, key2, externalDependencies = (0, _deepArray.finalize)([])) {
        this.key = void 0;
        this.manipulateOptions = void 0;
        this.post = void 0;
        this.pre = void 0;
        this.visitor = void 0;
        this.parserOverride = void 0;
        this.generatorOverride = void 0;
        this.options = void 0;
        this.externalDependencies = void 0;
        this.key = plugin2.name || key2;
        this.manipulateOptions = plugin2.manipulateOptions;
        this.post = plugin2.post;
        this.pre = plugin2.pre;
        this.visitor = plugin2.visitor || {};
        this.parserOverride = plugin2.parserOverride;
        this.generatorOverride = plugin2.generatorOverride;
        this.options = options;
        this.externalDependencies = externalDependencies;
      }
    };
    exports.default = Plugin;
  }
});

// node_modules/@babel/core/lib/gensync-utils/functional.js
var require_functional = __commonJS({
  "node_modules/@babel/core/lib/gensync-utils/functional.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.once = once;
    var _async = require_async();
    function once(fn) {
      let result;
      let resultP;
      return function* () {
        if (result)
          return result;
        if (!(yield* (0, _async.isAsync)()))
          return result = yield* fn();
        if (resultP)
          return yield* (0, _async.waitFor)(resultP);
        let resolve, reject;
        resultP = new Promise((res, rej) => {
          resolve = res;
          reject = rej;
        });
        try {
          result = yield* fn();
          resultP = null;
          resolve(result);
          return result;
        } catch (error) {
          reject(error);
          throw error;
        }
      };
    }
  }
});

// node_modules/node-releases/data/processed/envs.json
var require_envs = __commonJS({
  "node_modules/node-releases/data/processed/envs.json"(exports, module2) {
    module2.exports = [{ name: "nodejs", version: "0.2.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.3.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.4.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.5.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.6.0", date: "2011-11-04", lts: false, security: false }, { name: "nodejs", version: "0.7.0", date: "2012-01-17", lts: false, security: false }, { name: "nodejs", version: "0.8.0", date: "2012-06-22", lts: false, security: false }, { name: "nodejs", version: "0.9.0", date: "2012-07-20", lts: false, security: false }, { name: "nodejs", version: "0.10.0", date: "2013-03-11", lts: false, security: false }, { name: "nodejs", version: "0.11.0", date: "2013-03-28", lts: false, security: false }, { name: "nodejs", version: "0.12.0", date: "2015-02-06", lts: false, security: false }, { name: "nodejs", version: "4.0.0", date: "2015-09-08", lts: false, security: false }, { name: "nodejs", version: "4.1.0", date: "2015-09-17", lts: false, security: false }, { name: "nodejs", version: "4.2.0", date: "2015-10-12", lts: "Argon", security: false }, { name: "nodejs", version: "4.3.0", date: "2016-02-09", lts: "Argon", security: false }, { name: "nodejs", version: "4.4.0", date: "2016-03-08", lts: "Argon", security: false }, { name: "nodejs", version: "4.5.0", date: "2016-08-16", lts: "Argon", security: false }, { name: "nodejs", version: "4.6.0", date: "2016-09-27", lts: "Argon", security: true }, { name: "nodejs", version: "4.7.0", date: "2016-12-06", lts: "Argon", security: false }, { name: "nodejs", version: "4.8.0", date: "2017-02-21", lts: "Argon", security: false }, { name: "nodejs", version: "4.9.0", date: "2018-03-28", lts: "Argon", security: true }, { name: "nodejs", version: "5.0.0", date: "2015-10-29", lts: false, security: false }, { name: "nodejs", version: "5.1.0", date: "2015-11-17", lts: false, security: false }, { name: "nodejs", version: "5.2.0", date: "2015-12-09", lts: false, security: false }, { name: "nodejs", version: "5.3.0", date: "2015-12-15", lts: false, security: false }, { name: "nodejs", version: "5.4.0", date: "2016-01-06", lts: false, security: false }, { name: "nodejs", version: "5.5.0", date: "2016-01-21", lts: false, security: false }, { name: "nodejs", version: "5.6.0", date: "2016-02-09", lts: false, security: false }, { name: "nodejs", version: "5.7.0", date: "2016-02-23", lts: false, security: false }, { name: "nodejs", version: "5.8.0", date: "2016-03-09", lts: false, security: false }, { name: "nodejs", version: "5.9.0", date: "2016-03-16", lts: false, security: false }, { name: "nodejs", version: "5.10.0", date: "2016-04-01", lts: false, security: false }, { name: "nodejs", version: "5.11.0", date: "2016-04-21", lts: false, security: false }, { name: "nodejs", version: "5.12.0", date: "2016-06-23", lts: false, security: false }, { name: "nodejs", version: "6.0.0", date: "2016-04-26", lts: false, security: false }, { name: "nodejs", version: "6.1.0", date: "2016-05-05", lts: false, security: false }, { name: "nodejs", version: "6.2.0", date: "2016-05-17", lts: false, security: false }, { name: "nodejs", version: "6.3.0", date: "2016-07-06", lts: false, security: false }, { name: "nodejs", version: "6.4.0", date: "2016-08-12", lts: false, security: false }, { name: "nodejs", version: "6.5.0", date: "2016-08-26", lts: false, security: false }, { name: "nodejs", version: "6.6.0", date: "2016-09-14", lts: false, security: false }, { name: "nodejs", version: "6.7.0", date: "2016-09-27", lts: false, security: true }, { name: "nodejs", version: "6.8.0", date: "2016-10-12", lts: false, security: false }, { name: "nodejs", version: "6.9.0", date: "2016-10-18", lts: "Boron", security: false }, { name: "nodejs", version: "6.10.0", date: "2017-02-21", lts: "Boron", security: false }, { name: "nodejs", version: "6.11.0", date: "2017-06-06", lts: "Boron", security: false }, { name: "nodejs", version: "6.12.0", date: "2017-11-06", lts: "Boron", security: false }, { name: "nodejs", version: "6.13.0", date: "2018-02-10", lts: "Boron", security: false }, { name: "nodejs", version: "6.14.0", date: "2018-03-28", lts: "Boron", security: true }, { name: "nodejs", version: "6.15.0", date: "2018-11-27", lts: "Boron", security: true }, { name: "nodejs", version: "6.16.0", date: "2018-12-26", lts: "Boron", security: false }, { name: "nodejs", version: "6.17.0", date: "2019-02-28", lts: "Boron", security: true }, { name: "nodejs", version: "7.0.0", date: "2016-10-25", lts: false, security: false }, { name: "nodejs", version: "7.1.0", date: "2016-11-08", lts: false, security: false }, { name: "nodejs", version: "7.2.0", date: "2016-11-22", lts: false, security: false }, { name: "nodejs", version: "7.3.0", date: "2016-12-20", lts: false, security: false }, { name: "nodejs", version: "7.4.0", date: "2017-01-04", lts: false, security: false }, { name: "nodejs", version: "7.5.0", date: "2017-01-31", lts: false, security: false }, { name: "nodejs", version: "7.6.0", date: "2017-02-21", lts: false, security: false }, { name: "nodejs", version: "7.7.0", date: "2017-02-28", lts: false, security: false }, { name: "nodejs", version: "7.8.0", date: "2017-03-29", lts: false, security: false }, { name: "nodejs", version: "7.9.0", date: "2017-04-11", lts: false, security: false }, { name: "nodejs", version: "7.10.0", date: "2017-05-02", lts: false, security: false }, { name: "nodejs", version: "8.0.0", date: "2017-05-30", lts: false, security: false }, { name: "nodejs", version: "8.1.0", date: "2017-06-08", lts: false, security: false }, { name: "nodejs", version: "8.2.0", date: "2017-07-19", lts: false, security: false }, { name: "nodejs", version: "8.3.0", date: "2017-08-08", lts: false, security: false }, { name: "nodejs", version: "8.4.0", date: "2017-08-15", lts: false, security: false }, { name: "nodejs", version: "8.5.0", date: "2017-09-12", lts: false, security: false }, { name: "nodejs", version: "8.6.0", date: "2017-09-26", lts: false, security: false }, { name: "nodejs", version: "8.7.0", date: "2017-10-11", lts: false, security: false }, { name: "nodejs", version: "8.8.0", date: "2017-10-24", lts: false, security: false }, { name: "nodejs", version: "8.9.0", date: "2017-10-31", lts: "Carbon", security: false }, { name: "nodejs", version: "8.10.0", date: "2018-03-06", lts: "Carbon", security: false }, { name: "nodejs", version: "8.11.0", date: "2018-03-28", lts: "Carbon", security: true }, { name: "nodejs", version: "8.12.0", date: "2018-09-10", lts: "Carbon", security: false }, { name: "nodejs", version: "8.13.0", date: "2018-11-20", lts: "Carbon", security: false }, { name: "nodejs", version: "8.14.0", date: "2018-11-27", lts: "Carbon", security: true }, { name: "nodejs", version: "8.15.0", date: "2018-12-26", lts: "Carbon", security: false }, { name: "nodejs", version: "8.16.0", date: "2019-04-16", lts: "Carbon", security: false }, { name: "nodejs", version: "8.17.0", date: "2019-12-17", lts: "Carbon", security: true }, { name: "nodejs", version: "9.0.0", date: "2017-10-31", lts: false, security: false }, { name: "nodejs", version: "9.1.0", date: "2017-11-07", lts: false, security: false }, { name: "nodejs", version: "9.2.0", date: "2017-11-14", lts: false, security: false }, { name: "nodejs", version: "9.3.0", date: "2017-12-12", lts: false, security: false }, { name: "nodejs", version: "9.4.0", date: "2018-01-10", lts: false, security: false }, { name: "nodejs", version: "9.5.0", date: "2018-01-31", lts: false, security: false }, { name: "nodejs", version: "9.6.0", date: "2018-02-21", lts: false, security: false }, { name: "nodejs", version: "9.7.0", date: "2018-03-01", lts: false, security: false }, { name: "nodejs", version: "9.8.0", date: "2018-03-07", lts: false, security: false }, { name: "nodejs", version: "9.9.0", date: "2018-03-21", lts: false, security: false }, { name: "nodejs", version: "9.10.0", date: "2018-03-28", lts: false, security: true }, { name: "nodejs", version: "9.11.0", date: "2018-04-04", lts: false, security: false }, { name: "nodejs", version: "10.0.0", date: "2018-04-24", lts: false, security: false }, { name: "nodejs", version: "10.1.0", date: "2018-05-08", lts: false, security: false }, { name: "nodejs", version: "10.2.0", date: "2018-05-23", lts: false, security: false }, { name: "nodejs", version: "10.3.0", date: "2018-05-29", lts: false, security: false }, { name: "nodejs", version: "10.4.0", date: "2018-06-06", lts: false, security: false }, { name: "nodejs", version: "10.5.0", date: "2018-06-20", lts: false, security: false }, { name: "nodejs", version: "10.6.0", date: "2018-07-04", lts: false, security: false }, { name: "nodejs", version: "10.7.0", date: "2018-07-18", lts: false, security: false }, { name: "nodejs", version: "10.8.0", date: "2018-08-01", lts: false, security: false }, { name: "nodejs", version: "10.9.0", date: "2018-08-15", lts: false, security: false }, { name: "nodejs", version: "10.10.0", date: "2018-09-06", lts: false, security: false }, { name: "nodejs", version: "10.11.0", date: "2018-09-19", lts: false, security: false }, { name: "nodejs", version: "10.12.0", date: "2018-10-10", lts: false, security: false }, { name: "nodejs", version: "10.13.0", date: "2018-10-30", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.14.0", date: "2018-11-27", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.15.0", date: "2018-12-26", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.16.0", date: "2019-05-28", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.17.0", date: "2019-10-22", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.18.0", date: "2019-12-17", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.19.0", date: "2020-02-05", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.20.0", date: "2020-03-26", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.21.0", date: "2020-06-02", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.22.0", date: "2020-07-21", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.23.0", date: "2020-10-27", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.24.0", date: "2021-02-23", lts: "Dubnium", security: true }, { name: "nodejs", version: "11.0.0", date: "2018-10-23", lts: false, security: false }, { name: "nodejs", version: "11.1.0", date: "2018-10-30", lts: false, security: false }, { name: "nodejs", version: "11.2.0", date: "2018-11-15", lts: false, security: false }, { name: "nodejs", version: "11.3.0", date: "2018-11-27", lts: false, security: true }, { name: "nodejs", version: "11.4.0", date: "2018-12-07", lts: false, security: false }, { name: "nodejs", version: "11.5.0", date: "2018-12-18", lts: false, security: false }, { name: "nodejs", version: "11.6.0", date: "2018-12-26", lts: false, security: false }, { name: "nodejs", version: "11.7.0", date: "2019-01-17", lts: false, security: false }, { name: "nodejs", version: "11.8.0", date: "2019-01-24", lts: false, security: false }, { name: "nodejs", version: "11.9.0", date: "2019-01-30", lts: false, security: false }, { name: "nodejs", version: "11.10.0", date: "2019-02-14", lts: false, security: false }, { name: "nodejs", version: "11.11.0", date: "2019-03-05", lts: false, security: false }, { name: "nodejs", version: "11.12.0", date: "2019-03-14", lts: false, security: false }, { name: "nodejs", version: "11.13.0", date: "2019-03-28", lts: false, security: false }, { name: "nodejs", version: "11.14.0", date: "2019-04-10", lts: false, security: false }, { name: "nodejs", version: "11.15.0", date: "2019-04-30", lts: false, security: false }, { name: "nodejs", version: "12.0.0", date: "2019-04-23", lts: false, security: false }, { name: "nodejs", version: "12.1.0", date: "2019-04-29", lts: false, security: false }, { name: "nodejs", version: "12.2.0", date: "2019-05-07", lts: false, security: false }, { name: "nodejs", version: "12.3.0", date: "2019-05-21", lts: false, security: false }, { name: "nodejs", version: "12.4.0", date: "2019-06-04", lts: false, security: false }, { name: "nodejs", version: "12.5.0", date: "2019-06-26", lts: false, security: false }, { name: "nodejs", version: "12.6.0", date: "2019-07-03", lts: false, security: false }, { name: "nodejs", version: "12.7.0", date: "2019-07-23", lts: false, security: false }, { name: "nodejs", version: "12.8.0", date: "2019-08-06", lts: false, security: false }, { name: "nodejs", version: "12.9.0", date: "2019-08-20", lts: false, security: false }, { name: "nodejs", version: "12.10.0", date: "2019-09-04", lts: false, security: false }, { name: "nodejs", version: "12.11.0", date: "2019-09-25", lts: false, security: false }, { name: "nodejs", version: "12.12.0", date: "2019-10-11", lts: false, security: false }, { name: "nodejs", version: "12.13.0", date: "2019-10-21", lts: "Erbium", security: false }, { name: "nodejs", version: "12.14.0", date: "2019-12-17", lts: "Erbium", security: true }, { name: "nodejs", version: "12.15.0", date: "2020-02-05", lts: "Erbium", security: true }, { name: "nodejs", version: "12.16.0", date: "2020-02-11", lts: "Erbium", security: false }, { name: "nodejs", version: "12.17.0", date: "2020-05-26", lts: "Erbium", security: false }, { name: "nodejs", version: "12.18.0", date: "2020-06-02", lts: "Erbium", security: true }, { name: "nodejs", version: "12.19.0", date: "2020-10-06", lts: "Erbium", security: false }, { name: "nodejs", version: "12.20.0", date: "2020-11-24", lts: "Erbium", security: false }, { name: "nodejs", version: "12.21.0", date: "2021-02-23", lts: "Erbium", security: true }, { name: "nodejs", version: "12.22.0", date: "2021-03-30", lts: "Erbium", security: false }, { name: "nodejs", version: "13.0.0", date: "2019-10-22", lts: false, security: false }, { name: "nodejs", version: "13.1.0", date: "2019-11-05", lts: false, security: false }, { name: "nodejs", version: "13.2.0", date: "2019-11-21", lts: false, security: false }, { name: "nodejs", version: "13.3.0", date: "2019-12-03", lts: false, security: false }, { name: "nodejs", version: "13.4.0", date: "2019-12-17", lts: false, security: true }, { name: "nodejs", version: "13.5.0", date: "2019-12-18", lts: false, security: false }, { name: "nodejs", version: "13.6.0", date: "2020-01-07", lts: false, security: false }, { name: "nodejs", version: "13.7.0", date: "2020-01-21", lts: false, security: false }, { name: "nodejs", version: "13.8.0", date: "2020-02-05", lts: false, security: true }, { name: "nodejs", version: "13.9.0", date: "2020-02-18", lts: false, security: false }, { name: "nodejs", version: "13.10.0", date: "2020-03-04", lts: false, security: false }, { name: "nodejs", version: "13.11.0", date: "2020-03-12", lts: false, security: false }, { name: "nodejs", version: "13.12.0", date: "2020-03-26", lts: false, security: false }, { name: "nodejs", version: "13.13.0", date: "2020-04-14", lts: false, security: false }, { name: "nodejs", version: "13.14.0", date: "2020-04-29", lts: false, security: false }, { name: "nodejs", version: "14.0.0", date: "2020-04-21", lts: false, security: false }, { name: "nodejs", version: "14.1.0", date: "2020-04-29", lts: false, security: false }, { name: "nodejs", version: "14.2.0", date: "2020-05-05", lts: false, security: false }, { name: "nodejs", version: "14.3.0", date: "2020-05-19", lts: false, security: false }, { name: "nodejs", version: "14.4.0", date: "2020-06-02", lts: false, security: true }, { name: "nodejs", version: "14.5.0", date: "2020-06-30", lts: false, security: false }, { name: "nodejs", version: "14.6.0", date: "2020-07-20", lts: false, security: false }, { name: "nodejs", version: "14.7.0", date: "2020-07-29", lts: false, security: false }, { name: "nodejs", version: "14.8.0", date: "2020-08-11", lts: false, security: false }, { name: "nodejs", version: "14.9.0", date: "2020-08-27", lts: false, security: false }, { name: "nodejs", version: "14.10.0", date: "2020-09-08", lts: false, security: false }, { name: "nodejs", version: "14.11.0", date: "2020-09-15", lts: false, security: true }, { name: "nodejs", version: "14.12.0", date: "2020-09-22", lts: false, security: false }, { name: "nodejs", version: "14.13.0", date: "2020-09-29", lts: false, security: false }, { name: "nodejs", version: "14.14.0", date: "2020-10-15", lts: false, security: false }, { name: "nodejs", version: "14.15.0", date: "2020-10-27", lts: "Fermium", security: false }, { name: "nodejs", version: "14.16.0", date: "2021-02-23", lts: "Fermium", security: true }, { name: "nodejs", version: "14.17.0", date: "2021-05-11", lts: "Fermium", security: false }, { name: "nodejs", version: "14.18.0", date: "2021-09-28", lts: "Fermium", security: false }, { name: "nodejs", version: "14.19.0", date: "2022-02-01", lts: "Fermium", security: false }, { name: "nodejs", version: "14.20.0", date: "2022-07-07", lts: "Fermium", security: true }, { name: "nodejs", version: "14.21.0", date: "2022-11-01", lts: "Fermium", security: false }, { name: "nodejs", version: "15.0.0", date: "2020-10-20", lts: false, security: false }, { name: "nodejs", version: "15.1.0", date: "2020-11-04", lts: false, security: false }, { name: "nodejs", version: "15.2.0", date: "2020-11-10", lts: false, security: false }, { name: "nodejs", version: "15.3.0", date: "2020-11-24", lts: false, security: false }, { name: "nodejs", version: "15.4.0", date: "2020-12-09", lts: false, security: false }, { name: "nodejs", version: "15.5.0", date: "2020-12-22", lts: false, security: false }, { name: "nodejs", version: "15.6.0", date: "2021-01-14", lts: false, security: false }, { name: "nodejs", version: "15.7.0", date: "2021-01-25", lts: false, security: false }, { name: "nodejs", version: "15.8.0", date: "2021-02-02", lts: false, security: false }, { name: "nodejs", version: "15.9.0", date: "2021-02-18", lts: false, security: false }, { name: "nodejs", version: "15.10.0", date: "2021-02-23", lts: false, security: true }, { name: "nodejs", version: "15.11.0", date: "2021-03-03", lts: false, security: false }, { name: "nodejs", version: "15.12.0", date: "2021-03-17", lts: false, security: false }, { name: "nodejs", version: "15.13.0", date: "2021-03-31", lts: false, security: false }, { name: "nodejs", version: "15.14.0", date: "2021-04-06", lts: false, security: false }, { name: "nodejs", version: "16.0.0", date: "2021-04-20", lts: false, security: false }, { name: "nodejs", version: "16.1.0", date: "2021-05-04", lts: false, security: false }, { name: "nodejs", version: "16.2.0", date: "2021-05-19", lts: false, security: false }, { name: "nodejs", version: "16.3.0", date: "2021-06-03", lts: false, security: false }, { name: "nodejs", version: "16.4.0", date: "2021-06-23", lts: false, security: false }, { name: "nodejs", version: "16.5.0", date: "2021-07-14", lts: false, security: false }, { name: "nodejs", version: "16.6.0", date: "2021-07-29", lts: false, security: true }, { name: "nodejs", version: "16.7.0", date: "2021-08-18", lts: false, security: false }, { name: "nodejs", version: "16.8.0", date: "2021-08-25", lts: false, security: false }, { name: "nodejs", version: "16.9.0", date: "2021-09-07", lts: false, security: false }, { name: "nodejs", version: "16.10.0", date: "2021-09-22", lts: false, security: false }, { name: "nodejs", version: "16.11.0", date: "2021-10-08", lts: false, security: false }, { name: "nodejs", version: "16.12.0", date: "2021-10-20", lts: false, security: false }, { name: "nodejs", version: "16.13.0", date: "2021-10-26", lts: "Gallium", security: false }, { name: "nodejs", version: "16.14.0", date: "2022-02-08", lts: "Gallium", security: false }, { name: "nodejs", version: "16.15.0", date: "2022-04-26", lts: "Gallium", security: false }, { name: "nodejs", version: "16.16.0", date: "2022-07-07", lts: "Gallium", security: true }, { name: "nodejs", version: "16.17.0", date: "2022-08-16", lts: "Gallium", security: false }, { name: "nodejs", version: "16.18.0", date: "2022-10-12", lts: "Gallium", security: false }, { name: "nodejs", version: "16.19.0", date: "2022-12-13", lts: "Gallium", security: false }, { name: "nodejs", version: "17.0.0", date: "2021-10-19", lts: false, security: false }, { name: "nodejs", version: "17.1.0", date: "2021-11-09", lts: false, security: false }, { name: "nodejs", version: "17.2.0", date: "2021-11-30", lts: false, security: false }, { name: "nodejs", version: "17.3.0", date: "2021-12-17", lts: false, security: false }, { name: "nodejs", version: "17.4.0", date: "2022-01-18", lts: false, security: false }, { name: "nodejs", version: "17.5.0", date: "2022-02-10", lts: false, security: false }, { name: "nodejs", version: "17.6.0", date: "2022-02-22", lts: false, security: false }, { name: "nodejs", version: "17.7.0", date: "2022-03-09", lts: false, security: false }, { name: "nodejs", version: "17.8.0", date: "2022-03-22", lts: false, security: false }, { name: "nodejs", version: "17.9.0", date: "2022-04-07", lts: false, security: false }, { name: "nodejs", version: "18.0.0", date: "2022-04-18", lts: false, security: false }, { name: "nodejs", version: "18.1.0", date: "2022-05-03", lts: false, security: false }, { name: "nodejs", version: "18.2.0", date: "2022-05-17", lts: false, security: false }, { name: "nodejs", version: "18.3.0", date: "2022-06-02", lts: false, security: false }, { name: "nodejs", version: "18.4.0", date: "2022-06-16", lts: false, security: false }, { name: "nodejs", version: "18.5.0", date: "2022-07-06", lts: false, security: true }, { name: "nodejs", version: "18.6.0", date: "2022-07-13", lts: false, security: false }, { name: "nodejs", version: "18.7.0", date: "2022-07-26", lts: false, security: false }, { name: "nodejs", version: "18.8.0", date: "2022-08-24", lts: false, security: false }, { name: "nodejs", version: "18.9.0", date: "2022-09-07", lts: false, security: false }, { name: "nodejs", version: "18.10.0", date: "2022-09-28", lts: false, security: false }, { name: "nodejs", version: "18.11.0", date: "2022-10-13", lts: false, security: false }, { name: "nodejs", version: "18.12.0", date: "2022-10-25", lts: "Hydrogen", security: false }, { name: "nodejs", version: "18.13.0", date: "2023-01-05", lts: "Hydrogen", security: false }, { name: "nodejs", version: "18.14.0", date: "2023-02-01", lts: "Hydrogen", security: false }, { name: "nodejs", version: "19.0.0", date: "2022-10-17", lts: false, security: false }, { name: "nodejs", version: "19.1.0", date: "2022-11-14", lts: false, security: false }, { name: "nodejs", version: "19.2.0", date: "2022-11-29", lts: false, security: false }, { name: "nodejs", version: "19.3.0", date: "2022-12-14", lts: false, security: false }, { name: "nodejs", version: "19.4.0", date: "2023-01-05", lts: false, security: false }, { name: "nodejs", version: "19.5.0", date: "2023-01-24", lts: false, security: false }, { name: "nodejs", version: "19.6.0", date: "2023-02-01", lts: false, security: false }];
  }
});

// node_modules/caniuse-lite/data/browsers.js
var require_browsers = __commonJS({
  "node_modules/caniuse-lite/data/browsers.js"(exports, module2) {
    module2.exports = { A: "ie", B: "edge", C: "firefox", D: "chrome", E: "safari", F: "opera", G: "ios_saf", H: "op_mini", I: "android", J: "bb", K: "op_mob", L: "and_chr", M: "and_ff", N: "ie_mob", O: "and_uc", P: "samsung", Q: "and_qq", R: "baidu", S: "kaios" };
  }
});

// node_modules/caniuse-lite/dist/unpacker/browsers.js
var require_browsers2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/browsers.js"(exports, module2) {
    module2.exports.browsers = require_browsers();
  }
});

// node_modules/caniuse-lite/data/browserVersions.js
var require_browserVersions = __commonJS({
  "node_modules/caniuse-lite/data/browserVersions.js"(exports, module2) {
    module2.exports = { "0": "22", "1": "23", "2": "24", "3": "25", "4": "26", "5": "27", "6": "28", "7": "29", "8": "30", "9": "31", A: "10", B: "11", C: "12", D: "7", E: "8", F: "9", G: "15", H: "112", I: "4", J: "6", K: "13", L: "14", M: "16", N: "17", O: "18", P: "79", Q: "80", R: "81", S: "83", T: "84", U: "85", V: "86", W: "87", X: "88", Y: "89", Z: "90", a: "91", b: "92", c: "93", d: "94", e: "95", f: "110", g: "20", h: "73", i: "96", j: "97", k: "98", l: "99", m: "100", n: "101", o: "102", p: "103", q: "104", r: "105", s: "106", t: "107", u: "108", v: "109", w: "111", x: "5", y: "19", z: "21", AB: "32", BB: "33", CB: "34", DB: "35", EB: "36", FB: "37", GB: "38", HB: "39", IB: "40", JB: "41", KB: "42", LB: "43", MB: "44", NB: "45", OB: "46", PB: "47", QB: "48", RB: "49", SB: "50", TB: "51", UB: "52", VB: "53", WB: "54", XB: "55", YB: "56", ZB: "57", aB: "58", bB: "60", cB: "62", dB: "63", eB: "64", fB: "65", gB: "66", hB: "67", iB: "68", jB: "69", kB: "70", lB: "71", mB: "72", nB: "74", oB: "75", pB: "76", qB: "77", rB: "78", sB: "11.1", tB: "12.1", uB: "16.0", vB: "3", wB: "59", xB: "61", yB: "82", zB: "113", "0B": "114", "1B": "3.2", "2B": "10.1", "3B": "13.1", "4B": "15.2-15.3", "5B": "15.4", "6B": "15.5", "7B": "15.6", "8B": "16.1", "9B": "16.2", AC: "16.3", BC: "16.4", CC: "16.5", DC: "11.5", EC: "4.2-4.3", FC: "5.5", GC: "2", HC: "3.5", IC: "3.6", JC: "115", KC: "3.1", LC: "5.1", MC: "6.1", NC: "7.1", OC: "9.1", PC: "14.1", QC: "15.1", RC: "TP", SC: "9.5-9.6", TC: "10.0-10.1", UC: "10.5", VC: "10.6", WC: "11.6", XC: "4.0-4.1", YC: "5.0-5.1", ZC: "6.0-6.1", aC: "7.0-7.1", bC: "8.1-8.4", cC: "9.0-9.2", dC: "9.3", eC: "10.0-10.2", fC: "10.3", gC: "11.0-11.2", hC: "11.3-11.4", iC: "12.0-12.1", jC: "12.2-12.5", kC: "13.0-13.1", lC: "13.2", mC: "13.3", nC: "13.4-13.7", oC: "14.0-14.4", pC: "14.5-14.8", qC: "15.0-15.1", rC: "all", sC: "2.1", tC: "2.2", uC: "2.3", vC: "4.1", wC: "4.4", xC: "4.4.3-4.4.4", yC: "13.4", zC: "5.0-5.4", "0C": "6.2-6.4", "1C": "7.2-7.4", "2C": "8.2", "3C": "9.2", "4C": "11.1-11.2", "5C": "12.0", "6C": "13.0", "7C": "14.0", "8C": "15.0", "9C": "17.0", AD: "18.0", BD: "19.0", CD: "13.18", DD: "2.5", ED: "3.0-3.1" };
  }
});

// node_modules/caniuse-lite/dist/unpacker/browserVersions.js
var require_browserVersions2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/browserVersions.js"(exports, module2) {
    module2.exports.browserVersions = require_browserVersions();
  }
});

// node_modules/caniuse-lite/data/agents.js
var require_agents = __commonJS({
  "node_modules/caniuse-lite/data/agents.js"(exports, module2) {
    module2.exports = { A: { A: { J: 0.0131217, D: 621152e-8, E: 0.0497493, F: 0.0580409, A: 829156e-8, B: 0.406286, FC: 9298e-6 }, B: "ms", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "FC", "J", "D", "E", "F", "A", "B", "", "", ""], E: "IE", F: { FC: 962323200, J: 998870400, D: 1161129600, E: 1237420800, F: 1300060800, A: 1346716800, B: 1381968e3 } }, B: { A: { C: 4081e-6, K: 4267e-6, L: 4268e-6, G: 4081e-6, M: 3702e-6, N: 4081e-6, O: 0.016324, P: 0, Q: 4298e-6, R: 944e-5, S: 4043e-6, T: 4081e-6, U: 3861e-6, V: 3861e-6, W: 4081e-6, X: 3943e-6, Y: 4081e-6, Z: 3943e-6, a: 3943e-6, b: 8162e-6, c: 4118e-6, d: 3939e-6, e: 3943e-6, i: 3943e-6, j: 3943e-6, k: 3929e-6, l: 3901e-6, m: 0.011829, n: 7886e-6, o: 3943e-6, p: 8162e-6, q: 4081e-6, r: 4081e-6, s: 8162e-6, t: 0.016324, u: 0.044891, v: 0.118349, f: 2.0609, w: 2.19966, H: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "C", "K", "L", "G", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "f", "w", "H", "", "", ""], E: "Edge", F: { C: 1438128e3, K: 1447286400, L: 1470096e3, G: 1491868800, M: 1508198400, N: 1525046400, O: 1542067200, P: 1579046400, Q: 1581033600, R: 1586736e3, S: 1590019200, T: 1594857600, U: 1598486400, V: 1602201600, W: 1605830400, X: 161136e4, Y: 1614816e3, Z: 1618358400, a: 1622073600, b: 1626912e3, c: 1630627200, d: 1632441600, e: 1634774400, i: 1637539200, j: 1641427200, k: 1643932800, l: 1646265600, m: 1649635200, n: 1651190400, o: 1653955200, p: 1655942400, q: 1659657600, r: 1661990400, s: 1664755200, t: 1666915200, u: 1670198400, v: 1673481600, f: 1675900800, w: 1678665600, H: 1680825600 }, D: { C: "ms", K: "ms", L: "ms", G: "ms", M: "ms", N: "ms", O: "ms" } }, C: { A: { "0": 0.013698, "1": 4161e-6, "2": 8786e-6, "3": 4118e-6, "4": 4317e-6, "5": 4393e-6, "6": 4418e-6, "7": 8834e-6, "8": 8322e-6, "9": 8928e-6, GC: 4118e-6, vB: 4271e-6, I: 0.011703, x: 4879e-6, J: 0.020136, D: 5725e-6, E: 4525e-6, F: 533e-5, A: 4283e-6, B: 8162e-6, C: 4471e-6, K: 4486e-6, L: 453e-5, G: 8322e-6, M: 4417e-6, N: 4425e-6, O: 4161e-6, y: 4443e-6, g: 4283e-6, z: 8322e-6, AB: 4471e-6, BB: 9284e-6, CB: 4707e-6, DB: 9076e-6, EB: 4081e-6, FB: 4783e-6, GB: 3929e-6, HB: 4783e-6, IB: 487e-5, JB: 5029e-6, KB: 47e-4, LB: 0.012243, MB: 4081e-6, NB: 3867e-6, OB: 4525e-6, PB: 4293e-6, QB: 4081e-6, RB: 4538e-6, SB: 8282e-6, TB: 0.011601, UB: 0.044891, VB: 0.011601, WB: 3929e-6, XB: 3974e-6, YB: 8162e-6, ZB: 0.011601, aB: 3939e-6, wB: 4081e-6, bB: 3929e-6, xB: 4356e-6, cB: 4425e-6, dB: 8322e-6, eB: 415e-5, fB: 4267e-6, gB: 3801e-6, hB: 4267e-6, iB: 4081e-6, jB: 415e-5, kB: 4293e-6, lB: 4425e-6, mB: 8162e-6, h: 415e-5, nB: 415e-5, oB: 4318e-6, pB: 4356e-6, qB: 3974e-6, rB: 0.036729, P: 4081e-6, Q: 4081e-6, R: 4081e-6, yB: 3861e-6, S: 4081e-6, T: 3929e-6, U: 4268e-6, V: 3801e-6, W: 0.012243, X: 8162e-6, Y: 3943e-6, Z: 3943e-6, a: 0.012243, b: 3801e-6, c: 7722e-6, d: 0.016324, e: 3773e-6, i: 7886e-6, j: 3901e-6, k: 3901e-6, l: 4081e-6, m: 3861e-6, n: 4081e-6, o: 0.110187, p: 0.036729, q: 8162e-6, r: 8162e-6, s: 8162e-6, t: 0.012243, u: 0.024486, v: 0.053053, f: 1.10187, w: 0.926387, H: 8162e-6, zB: 0, "0B": 0, HC: 8786e-6, IC: 487e-5 }, B: "moz", C: ["GC", "vB", "HC", "IC", "I", "x", "J", "D", "E", "F", "A", "B", "C", "K", "L", "G", "M", "N", "O", "y", "g", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "HB", "IB", "JB", "KB", "LB", "MB", "NB", "OB", "PB", "QB", "RB", "SB", "TB", "UB", "VB", "WB", "XB", "YB", "ZB", "aB", "wB", "bB", "xB", "cB", "dB", "eB", "fB", "gB", "hB", "iB", "jB", "kB", "lB", "mB", "h", "nB", "oB", "pB", "qB", "rB", "P", "Q", "R", "yB", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "f", "w", "H", "zB", "0B", ""], E: "Firefox", F: { "0": 1368489600, "1": 1372118400, "2": 1375747200, "3": 1379376e3, "4": 1386633600, "5": 1391472e3, "6": 1395100800, "7": 1398729600, "8": 1402358400, "9": 1405987200, GC: 1161648e3, vB: 1213660800, HC: 124632e4, IC: 1264032e3, I: 1300752e3, x: 1308614400, J: 1313452800, D: 1317081600, E: 1317081600, F: 1320710400, A: 1324339200, B: 1327968e3, C: 1331596800, K: 1335225600, L: 1338854400, G: 1342483200, M: 1346112e3, N: 1349740800, O: 1353628800, y: 1357603200, g: 1361232e3, z: 1364860800, AB: 1409616e3, BB: 1413244800, CB: 1417392e3, DB: 1421107200, EB: 1424736e3, FB: 1428278400, GB: 1431475200, HB: 1435881600, IB: 1439251200, JB: 144288e4, KB: 1446508800, LB: 1450137600, MB: 1453852800, NB: 1457395200, OB: 1461628800, PB: 1465257600, QB: 1470096e3, RB: 1474329600, SB: 1479168e3, TB: 1485216e3, UB: 1488844800, VB: 149256e4, WB: 1497312e3, XB: 1502150400, YB: 1506556800, ZB: 1510617600, aB: 1516665600, wB: 1520985600, bB: 1525824e3, xB: 1529971200, cB: 1536105600, dB: 1540252800, eB: 1544486400, fB: 154872e4, gB: 1552953600, hB: 1558396800, iB: 1562630400, jB: 1567468800, kB: 1571788800, lB: 1575331200, mB: 1578355200, h: 1581379200, nB: 1583798400, oB: 1586304e3, pB: 1588636800, qB: 1591056e3, rB: 1593475200, P: 1595894400, Q: 1598313600, R: 1600732800, yB: 1603152e3, S: 1605571200, T: 1607990400, U: 1611619200, V: 1614038400, W: 1616457600, X: 1618790400, Y: 1622505600, Z: 1626134400, a: 1628553600, b: 1630972800, c: 1633392e3, d: 1635811200, e: 1638835200, i: 1641859200, j: 1644364800, k: 1646697600, l: 1649116800, m: 1651536e3, n: 1653955200, o: 1656374400, p: 1658793600, q: 1661212800, r: 1663632e3, s: 1666051200, t: 1668470400, u: 1670889600, v: 1673913600, f: 1676332800, w: 1678752e3, H: 1681171200, zB: null, "0B": null } }, D: { A: { "0": 3901e-6, "1": 8786e-6, "2": 3939e-6, "3": 4461e-6, "4": 4141e-6, "5": 4326e-6, "6": 47e-4, "7": 4538e-6, "8": 8322e-6, "9": 8596e-6, I: 4706e-6, x: 4879e-6, J: 4879e-6, D: 5591e-6, E: 5591e-6, F: 5591e-6, A: 4534e-6, B: 4464e-6, C: 0.010424, K: 83e-4, L: 4706e-6, G: 0.015087, M: 4393e-6, N: 4393e-6, O: 8652e-6, y: 8322e-6, g: 4393e-6, z: 4317e-6, AB: 4566e-6, BB: 4118e-6, CB: 4081e-6, DB: 8162e-6, EB: 4335e-6, FB: 4464e-6, GB: 0.016324, HB: 3867e-6, IB: 0.016324, JB: 3773e-6, KB: 3974e-6, LB: 8162e-6, MB: 7948e-6, NB: 3974e-6, OB: 3867e-6, PB: 8162e-6, QB: 0.020405, RB: 0.036729, SB: 3867e-6, TB: 4081e-6, UB: 8162e-6, VB: 8162e-6, WB: 3867e-6, XB: 4081e-6, YB: 0.073458, ZB: 4081e-6, aB: 0.015772, wB: 3773e-6, bB: 0.016324, xB: 8162e-6, cB: 3773e-6, dB: 0.012243, eB: 3943e-6, fB: 8162e-6, gB: 0.028567, hB: 8162e-6, iB: 8162e-6, jB: 0.036729, kB: 0.016324, lB: 0.012243, mB: 0.020405, h: 8162e-6, nB: 0.036729, oB: 0.048972, pB: 0.044891, qB: 0.016324, rB: 0.024486, P: 0.134673, Q: 0.036729, R: 0.04081, S: 0.065296, T: 0.04081, U: 0.089782, V: 0.065296, W: 0.097944, X: 0.020405, Y: 0.036729, Z: 0.04081, a: 0.077539, b: 0.044891, c: 0.085701, d: 0.044891, e: 0.032648, i: 0.04081, j: 0.053053, k: 0.04081, l: 0.053053, m: 0.053053, n: 0.048972, o: 0.073458, p: 0.355047, q: 0.114268, r: 0.106106, s: 0.077539, t: 0.126511, u: 0.399938, v: 2.73019, f: 7.54169, w: 10.7208, H: 0.020405, zB: 0.020405, "0B": 4081e-6, JC: 0 }, B: "webkit", C: ["", "", "", "", "", "I", "x", "J", "D", "E", "F", "A", "B", "C", "K", "L", "G", "M", "N", "O", "y", "g", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "HB", "IB", "JB", "KB", "LB", "MB", "NB", "OB", "PB", "QB", "RB", "SB", "TB", "UB", "VB", "WB", "XB", "YB", "ZB", "aB", "wB", "bB", "xB", "cB", "dB", "eB", "fB", "gB", "hB", "iB", "jB", "kB", "lB", "mB", "h", "nB", "oB", "pB", "qB", "rB", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "f", "w", "H", "zB", "0B", "JC"], E: "Chrome", F: { "0": 1343692800, "1": 1348531200, "2": 1352246400, "3": 1357862400, "4": 1361404800, "5": 1364428800, "6": 1369094400, "7": 1374105600, "8": 1376956800, "9": 1384214400, I: 1264377600, x: 1274745600, J: 1283385600, D: 1287619200, E: 1291248e3, F: 1296777600, A: 1299542400, B: 1303862400, C: 1307404800, K: 1312243200, L: 1316131200, G: 1316131200, M: 1319500800, N: 1323734400, O: 1328659200, y: 1332892800, g: 133704e4, z: 1340668800, AB: 1389657600, BB: 1392940800, CB: 1397001600, DB: 1400544e3, EB: 1405468800, FB: 1409011200, GB: 141264e4, HB: 1416268800, IB: 1421798400, JB: 1425513600, KB: 1429401600, LB: 143208e4, MB: 1437523200, NB: 1441152e3, OB: 1444780800, PB: 1449014400, QB: 1453248e3, RB: 1456963200, SB: 1460592e3, TB: 1464134400, UB: 1469059200, VB: 1472601600, WB: 1476230400, XB: 1480550400, YB: 1485302400, ZB: 1489017600, aB: 149256e4, wB: 1496707200, bB: 1500940800, xB: 1504569600, cB: 1508198400, dB: 1512518400, eB: 1516752e3, fB: 1520294400, gB: 1523923200, hB: 1527552e3, iB: 1532390400, jB: 1536019200, kB: 1539648e3, lB: 1543968e3, mB: 154872e4, h: 1552348800, nB: 1555977600, oB: 1559606400, pB: 1564444800, qB: 1568073600, rB: 1571702400, P: 1575936e3, Q: 1580860800, R: 1586304e3, S: 1589846400, T: 1594684800, U: 1598313600, V: 1601942400, W: 1605571200, X: 1611014400, Y: 1614556800, Z: 1618272e3, a: 1621987200, b: 1626739200, c: 1630368e3, d: 1632268800, e: 1634601600, i: 1637020800, j: 1641340800, k: 1643673600, l: 1646092800, m: 1648512e3, n: 1650931200, o: 1653350400, p: 1655769600, q: 1659398400, r: 1661817600, s: 1664236800, t: 1666656e3, u: 166968e4, v: 1673308800, f: 1675728e3, w: 1678147200, H: 1680566400, zB: null, "0B": null, JC: null } }, E: { A: { I: 0, x: 8322e-6, J: 4656e-6, D: 4465e-6, E: 3974e-6, F: 3929e-6, A: 4425e-6, B: 4318e-6, C: 3801e-6, K: 0.020405, L: 0.102025, G: 0.024486, KC: 0, "1B": 8692e-6, LC: 8162e-6, MC: 456e-5, NC: 4283e-6, OC: 0.028567, "2B": 7802e-6, sB: 8162e-6, tB: 0.036729, "3B": 0.183645, PC: 0.289751, QC: 0.044891, "4B": 0.036729, "5B": 0.093863, "6B": 0.171402, "7B": 0.754985, uB: 0.08162, "8B": 0.261184, "9B": 0.465234, AC: 1.69361, BC: 0.028567, CC: 0, RC: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "KC", "1B", "I", "x", "LC", "J", "MC", "D", "NC", "E", "F", "OC", "A", "2B", "B", "sB", "C", "tB", "K", "3B", "L", "PC", "G", "QC", "4B", "5B", "6B", "7B", "uB", "8B", "9B", "AC", "BC", "CC", "RC", ""], E: "Safari", F: { KC: 1205798400, "1B": 1226534400, I: 1244419200, x: 1275868800, LC: 131112e4, J: 1343174400, MC: 13824e5, D: 13824e5, NC: 1410998400, E: 1413417600, F: 1443657600, OC: 1458518400, A: 1474329600, "2B": 1490572800, B: 1505779200, sB: 1522281600, C: 1537142400, tB: 1553472e3, K: 1568851200, "3B": 1585008e3, L: 1600214400, PC: 1619395200, G: 1632096e3, QC: 1635292800, "4B": 1639353600, "5B": 1647216e3, "6B": 1652745600, "7B": 1658275200, uB: 1662940800, "8B": 1666569600, "9B": 1670889600, AC: 1674432e3, BC: 1679875200, CC: null, RC: null } }, F: { A: { "0": 6597e-6, "1": 0.013434, "2": 6702e-6, "3": 6015e-6, "4": 5595e-6, "5": 4393e-6, "6": 8162e-6, "7": 4879e-6, "8": 4879e-6, "9": 3861e-6, F: 82e-4, B: 0.016581, C: 4317e-6, G: 685e-5, M: 685e-5, N: 685e-5, O: 5014e-6, y: 6015e-6, g: 4879e-6, z: 6597e-6, AB: 5152e-6, BB: 5014e-6, CB: 9758e-6, DB: 4879e-6, EB: 4081e-6, FB: 4283e-6, GB: 4367e-6, HB: 4534e-6, IB: 4081e-6, JB: 4227e-6, KB: 4418e-6, LB: 4161e-6, MB: 4227e-6, NB: 4725e-6, OB: 0.012243, PB: 8942e-6, QB: 4707e-6, RB: 4827e-6, SB: 4707e-6, TB: 4707e-6, UB: 4326e-6, VB: 8922e-6, WB: 0.014349, XB: 4425e-6, YB: 472e-5, ZB: 4425e-6, aB: 4425e-6, bB: 472e-5, cB: 4532e-6, dB: 4566e-6, eB: 0.02283, fB: 867e-5, gB: 4656e-6, hB: 4642e-6, iB: 3929e-6, jB: 944e-5, kB: 4293e-6, lB: 3929e-6, mB: 4298e-6, h: 0.096692, nB: 8162e-6, oB: 4141e-6, pB: 4257e-6, qB: 3939e-6, rB: 8236e-6, P: 3855e-6, Q: 3939e-6, R: 8514e-6, yB: 3939e-6, S: 3939e-6, T: 3702e-6, U: 4081e-6, V: 3855e-6, W: 3855e-6, X: 3929e-6, Y: 3861e-6, Z: 0.011703, a: 7546e-6, b: 0.011829, c: 0.069498, d: 0.020405, e: 0.514206, SC: 685e-5, TC: 0, UC: 8392e-6, VC: 4706e-6, sB: 6229e-6, DC: 4879e-6, WC: 8786e-6, tB: 472e-5 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "F", "SC", "TC", "UC", "VC", "B", "sB", "DC", "WC", "C", "tB", "G", "M", "N", "O", "y", "g", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "HB", "IB", "JB", "KB", "LB", "MB", "NB", "OB", "PB", "QB", "RB", "SB", "TB", "UB", "VB", "WB", "XB", "YB", "ZB", "aB", "bB", "cB", "dB", "eB", "fB", "gB", "hB", "iB", "jB", "kB", "lB", "mB", "h", "nB", "oB", "pB", "qB", "rB", "P", "Q", "R", "yB", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "", "", ""], E: "Opera", F: { "0": 1401753600, "1": 1405987200, "2": 1409616e3, "3": 1413331200, "4": 1417132800, "5": 1422316800, "6": 1425945600, "7": 1430179200, "8": 1433808e3, "9": 1438646400, F: 1150761600, SC: 1223424e3, TC: 1251763200, UC: 1267488e3, VC: 1277942400, B: 1292457600, sB: 1302566400, DC: 1309219200, WC: 1323129600, C: 1323129600, tB: 1352073600, G: 1372723200, M: 1377561600, N: 1381104e3, O: 1386288e3, y: 1390867200, g: 1393891200, z: 1399334400, AB: 1442448e3, BB: 1445904e3, CB: 1449100800, DB: 1454371200, EB: 1457308800, FB: 146232e4, GB: 1465344e3, HB: 1470096e3, IB: 1474329600, JB: 1477267200, KB: 1481587200, LB: 1486425600, MB: 1490054400, NB: 1494374400, OB: 1498003200, PB: 1502236800, QB: 1506470400, RB: 1510099200, SB: 1515024e3, TB: 1517961600, UB: 1521676800, VB: 1525910400, WB: 1530144e3, XB: 1534982400, YB: 1537833600, ZB: 1543363200, aB: 1548201600, bB: 1554768e3, cB: 1561593600, dB: 1566259200, eB: 1570406400, fB: 1573689600, gB: 1578441600, hB: 1583971200, iB: 1587513600, jB: 1592956800, kB: 1595894400, lB: 1600128e3, mB: 1603238400, h: 161352e4, nB: 1612224e3, oB: 1616544e3, pB: 1619568e3, qB: 1623715200, rB: 1627948800, P: 1631577600, Q: 1633392e3, R: 1635984e3, yB: 1638403200, S: 1642550400, T: 1644969600, U: 1647993600, V: 1650412800, W: 1652745600, X: 1654646400, Y: 1657152e3, Z: 1660780800, a: 1663113600, b: 1668816e3, c: 1668643200, d: 1671062400, e: 1675209600 }, D: { F: "o", B: "o", C: "o", SC: "o", TC: "o", UC: "o", VC: "o", sB: "o", DC: "o", WC: "o", tB: "o" } }, G: { A: { E: 0, "1B": 0, XC: 0, EC: 316399e-8, YC: 474599e-8, ZC: 316399e-8, aC: 0.014238, bC: 790998e-8, cC: 0.018984, dC: 0.0569519, eC: 316399e-8, fC: 0.0696078, gC: 0.0205659, hC: 0.0237299, iC: 0.0205659, jC: 0.376515, kC: 0.012656, lC: 0.0348039, mC: 0.0316399, nC: 0.0996657, oC: 0.259447, pC: 0.480927, qC: 0.14238, "4B": 0.177184, "5B": 0.207241, "6B": 0.357531, "7B": 1.01406, uB: 1.11214, "8B": 2.47741, "9B": 1.67533, AC: 6.04164, BC: 0.11865, CC: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "1B", "XC", "EC", "YC", "ZC", "aC", "E", "bC", "cC", "dC", "eC", "fC", "gC", "hC", "iC", "jC", "kC", "lC", "mC", "nC", "oC", "pC", "qC", "4B", "5B", "6B", "7B", "uB", "8B", "9B", "AC", "BC", "CC", "", ""], E: "Safari on iOS", F: { "1B": 1270252800, XC: 1283904e3, EC: 1299628800, YC: 1331078400, ZC: 1359331200, aC: 1394409600, E: 1410912e3, bC: 1413763200, cC: 1442361600, dC: 1458518400, eC: 1473724800, fC: 1490572800, gC: 1505779200, hC: 1522281600, iC: 1537142400, jC: 1553472e3, kC: 1568851200, lC: 1572220800, mC: 1580169600, nC: 1585008e3, oC: 1600214400, pC: 1619395200, qC: 1632096e3, "4B": 1639353600, "5B": 1647216e3, "6B": 1652659200, "7B": 1658275200, uB: 1662940800, "8B": 1666569600, "9B": 1670889600, AC: 1674432e3, BC: 1679875200, CC: null } }, H: { A: { rC: 1.0085 }, B: "o", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "rC", "", "", ""], E: "Opera Mini", F: { rC: 1426464e3 } }, I: { A: { vB: 0, I: 0.0240008, H: 0, sC: 0, tC: 0.0720023, uC: 0, vC: 0.0160005, EC: 0.0720023, wC: 0, xC: 0.248008 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "sC", "tC", "uC", "vB", "I", "vC", "EC", "wC", "xC", "H", "", "", ""], E: "Android Browser", F: { sC: 1256515200, tC: 1274313600, uC: 1291593600, vB: 1298332800, I: 1318896e3, vC: 1341792e3, EC: 1374624e3, wC: 1386547200, xC: 1401667200, H: 1680652800 } }, J: { A: { D: 0, A: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "D", "A", "", "", ""], E: "Blackberry Browser", F: { D: 1325376e3, A: 1359504e3 } }, K: { A: { A: 0, B: 0, C: 0, h: 0.0111391, sB: 0, DC: 0, tB: 0 }, B: "o", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "A", "B", "sB", "DC", "C", "tB", "h", "", "", ""], E: "Opera Mobile", F: { A: 1287100800, B: 1300752e3, sB: 1314835200, DC: 1318291200, C: 1330300800, tB: 1349740800, h: 1673827200 }, D: { h: "webkit" } }, L: { A: { H: 40.8907 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "H", "", "", ""], E: "Chrome for Android", F: { H: 1680652800 } }, M: { A: { f: 0.2959 }, B: "moz", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "f", "", "", ""], E: "Firefox for Android", F: { f: 1676332800 } }, N: { A: { A: 0.0115934, B: 0.022664 }, B: "ms", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "A", "B", "", "", ""], E: "IE Mobile", F: { A: 1340150400, B: 1353456e3 } }, O: { A: { yC: 0.905454 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "yC", "", "", ""], E: "UC Browser for Android", F: { yC: 1634688e3 }, D: { yC: "webkit" } }, P: { A: { I: 0.147621, g: 1.90853, zC: 0.0103543, "0C": 0.010304, "1C": 0.0527219, "2C": 0.0103584, "3C": 0.0104443, "2B": 0.0105043, "4C": 0.0210887, "5C": 0.0103982, "6C": 0.0316331, "7C": 0.0316331, "8C": 0.0210887, uB: 0.0527219, "9C": 0.0632662, AD: 0.0738106, BD: 0.253065 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "I", "zC", "0C", "1C", "2C", "3C", "2B", "4C", "5C", "6C", "7C", "8C", "uB", "9C", "AD", "BD", "g", "", "", ""], E: "Samsung Internet", F: { I: 1461024e3, zC: 1481846400, "0C": 1509408e3, "1C": 1528329600, "2C": 1546128e3, "3C": 1554163200, "2B": 1567900800, "4C": 1582588800, "5C": 1593475200, "6C": 1605657600, "7C": 1618531200, "8C": 1629072e3, uB: 1640736e3, "9C": 1651708800, AD: 1659657600, BD: 1667260800, g: 1677369600 } }, Q: { A: { "3B": 0.11836 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "3B", "", "", ""], E: "QQ Browser", F: { "3B": 1663718400 } }, R: { A: { CD: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "CD", "", "", ""], E: "Baidu Browser", F: { CD: 1663027200 } }, S: { A: { DD: 0.071016, ED: 0 }, B: "moz", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "DD", "ED", "", "", ""], E: "KaiOS Browser", F: { DD: 1527811200, ED: 1631664e3 } } };
  }
});

// node_modules/caniuse-lite/dist/unpacker/agents.js
var require_agents2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/agents.js"(exports, module2) {
    "use strict";
    var browsers = require_browsers2().browsers;
    var versions = require_browserVersions2().browserVersions;
    var agentsData = require_agents();
    function unpackBrowserVersions(versionsData) {
      return Object.keys(versionsData).reduce((usage, version3) => {
        usage[versions[version3]] = versionsData[version3];
        return usage;
      }, {});
    }
    module2.exports.agents = Object.keys(agentsData).reduce((map, key2) => {
      let versionsData = agentsData[key2];
      map[browsers[key2]] = Object.keys(versionsData).reduce((data3, entry) => {
        if (entry === "A") {
          data3.usage_global = unpackBrowserVersions(versionsData[entry]);
        } else if (entry === "C") {
          data3.versions = versionsData[entry].reduce((list3, version3) => {
            if (version3 === "") {
              list3.push(null);
            } else {
              list3.push(versions[version3]);
            }
            return list3;
          }, []);
        } else if (entry === "D") {
          data3.prefix_exceptions = unpackBrowserVersions(versionsData[entry]);
        } else if (entry === "E") {
          data3.browser = versionsData[entry];
        } else if (entry === "F") {
          data3.release_date = Object.keys(versionsData[entry]).reduce(
            (map2, key22) => {
              map2[versions[key22]] = versionsData[entry][key22];
              return map2;
            },
            {}
          );
        } else {
          data3.prefix = versionsData[entry];
        }
        return data3;
      }, {});
      return map;
    }, {});
  }
});

// node_modules/node-releases/data/release-schedule/release-schedule.json
var require_release_schedule = __commonJS({
  "node_modules/node-releases/data/release-schedule/release-schedule.json"(exports, module2) {
    module2.exports = { "v0.8": { start: "2012-06-25", end: "2014-07-31" }, "v0.10": { start: "2013-03-11", end: "2016-10-31" }, "v0.12": { start: "2015-02-06", end: "2016-12-31" }, v4: { start: "2015-09-08", lts: "2015-10-12", maintenance: "2017-04-01", end: "2018-04-30", codename: "Argon" }, v5: { start: "2015-10-29", maintenance: "2016-04-30", end: "2016-06-30" }, v6: { start: "2016-04-26", lts: "2016-10-18", maintenance: "2018-04-30", end: "2019-04-30", codename: "Boron" }, v7: { start: "2016-10-25", maintenance: "2017-04-30", end: "2017-06-30" }, v8: { start: "2017-05-30", lts: "2017-10-31", maintenance: "2019-01-01", end: "2019-12-31", codename: "Carbon" }, v9: { start: "2017-10-01", maintenance: "2018-04-01", end: "2018-06-30" }, v10: { start: "2018-04-24", lts: "2018-10-30", maintenance: "2020-05-19", end: "2021-04-30", codename: "Dubnium" }, v11: { start: "2018-10-23", maintenance: "2019-04-22", end: "2019-06-01" }, v12: { start: "2019-04-23", lts: "2019-10-21", maintenance: "2020-11-30", end: "2022-04-30", codename: "Erbium" }, v13: { start: "2019-10-22", maintenance: "2020-04-01", end: "2020-06-01" }, v14: { start: "2020-04-21", lts: "2020-10-27", maintenance: "2021-10-19", end: "2023-04-30", codename: "Fermium" }, v15: { start: "2020-10-20", maintenance: "2021-04-01", end: "2021-06-01" }, v16: { start: "2021-04-20", lts: "2021-10-26", maintenance: "2022-10-18", end: "2023-09-11", codename: "Gallium" }, v17: { start: "2021-10-19", maintenance: "2022-04-01", end: "2022-06-01" }, v18: { start: "2022-04-19", lts: "2022-10-25", maintenance: "2023-10-18", end: "2025-04-30", codename: "Hydrogen" }, v19: { start: "2022-10-18", maintenance: "2023-04-01", end: "2023-06-01" }, v20: { start: "2023-04-18", lts: "2023-10-24", maintenance: "2024-10-22", end: "2026-04-30", codename: "" } };
  }
});

// node_modules/electron-to-chromium/versions.js
var require_versions = __commonJS({
  "node_modules/electron-to-chromium/versions.js"(exports, module2) {
    module2.exports = {
      "0.20": "39",
      "0.21": "41",
      "0.22": "41",
      "0.23": "41",
      "0.24": "41",
      "0.25": "42",
      "0.26": "42",
      "0.27": "43",
      "0.28": "43",
      "0.29": "43",
      "0.30": "44",
      "0.31": "45",
      "0.32": "45",
      "0.33": "45",
      "0.34": "45",
      "0.35": "45",
      "0.36": "47",
      "0.37": "49",
      "1.0": "49",
      "1.1": "50",
      "1.2": "51",
      "1.3": "52",
      "1.4": "53",
      "1.5": "54",
      "1.6": "56",
      "1.7": "58",
      "1.8": "59",
      "2.0": "61",
      "2.1": "61",
      "3.0": "66",
      "3.1": "66",
      "4.0": "69",
      "4.1": "69",
      "4.2": "69",
      "5.0": "73",
      "6.0": "76",
      "6.1": "76",
      "7.0": "78",
      "7.1": "78",
      "7.2": "78",
      "7.3": "78",
      "8.0": "80",
      "8.1": "80",
      "8.2": "80",
      "8.3": "80",
      "8.4": "80",
      "8.5": "80",
      "9.0": "83",
      "9.1": "83",
      "9.2": "83",
      "9.3": "83",
      "9.4": "83",
      "10.0": "85",
      "10.1": "85",
      "10.2": "85",
      "10.3": "85",
      "10.4": "85",
      "11.0": "87",
      "11.1": "87",
      "11.2": "87",
      "11.3": "87",
      "11.4": "87",
      "11.5": "87",
      "12.0": "89",
      "12.1": "89",
      "12.2": "89",
      "13.0": "91",
      "13.1": "91",
      "13.2": "91",
      "13.3": "91",
      "13.4": "91",
      "13.5": "91",
      "13.6": "91",
      "14.0": "93",
      "14.1": "93",
      "14.2": "93",
      "15.0": "94",
      "15.1": "94",
      "15.2": "94",
      "15.3": "94",
      "15.4": "94",
      "15.5": "94",
      "16.0": "96",
      "16.1": "96",
      "16.2": "96",
      "17.0": "98",
      "17.1": "98",
      "17.2": "98",
      "17.3": "98",
      "17.4": "98",
      "18.0": "100",
      "18.1": "100",
      "18.2": "100",
      "18.3": "100",
      "19.0": "102",
      "19.1": "102",
      "20.0": "104",
      "20.1": "104",
      "20.2": "104",
      "20.3": "104",
      "21.0": "106",
      "21.1": "106",
      "21.2": "106",
      "21.3": "106",
      "21.4": "106",
      "22.0": "108",
      "22.1": "108",
      "22.2": "108",
      "22.3": "108",
      "23.0": "110",
      "23.1": "110",
      "23.2": "110",
      "24.0": "112",
      "24.1": "112",
      "25.0": "114"
    };
  }
});

// node_modules/browserslist/error.js
var require_error = __commonJS({
  "node_modules/browserslist/error.js"(exports, module2) {
    function BrowserslistError(message) {
      this.name = "BrowserslistError";
      this.message = message;
      this.browserslist = true;
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, BrowserslistError);
      }
    }
    BrowserslistError.prototype = Error.prototype;
    module2.exports = BrowserslistError;
  }
});

// node_modules/browserslist/parse.js
var require_parse2 = __commonJS({
  "node_modules/browserslist/parse.js"(exports, module2) {
    var AND_REGEXP = /^\s+and\s+(.*)/i;
    var OR_REGEXP = /^(?:,\s*|\s+or\s+)(.*)/i;
    function flatten(array) {
      if (!Array.isArray(array))
        return [array];
      return array.reduce(function(a, b) {
        return a.concat(flatten(b));
      }, []);
    }
    function find2(string3, predicate) {
      for (var n = 1, max = string3.length; n <= max; n++) {
        var parsed = string3.substr(-n, n);
        if (predicate(parsed, n, max)) {
          return string3.slice(0, -n);
        }
      }
      return "";
    }
    function matchQuery(all4, query) {
      var node2 = { query };
      if (query.indexOf("not ") === 0) {
        node2.not = true;
        query = query.slice(4);
      }
      for (var name2 in all4) {
        var type = all4[name2];
        var match = query.match(type.regexp);
        if (match) {
          node2.type = name2;
          for (var i = 0; i < type.matches.length; i++) {
            node2[type.matches[i]] = match[i + 1];
          }
          return node2;
        }
      }
      node2.type = "unknown";
      return node2;
    }
    function matchBlock(all4, string3, qs) {
      var node2;
      return find2(string3, function(parsed, n, max) {
        if (AND_REGEXP.test(parsed)) {
          node2 = matchQuery(all4, parsed.match(AND_REGEXP)[1]);
          node2.compose = "and";
          qs.unshift(node2);
          return true;
        } else if (OR_REGEXP.test(parsed)) {
          node2 = matchQuery(all4, parsed.match(OR_REGEXP)[1]);
          node2.compose = "or";
          qs.unshift(node2);
          return true;
        } else if (n === max) {
          node2 = matchQuery(all4, parsed.trim());
          node2.compose = "or";
          qs.unshift(node2);
          return true;
        }
        return false;
      });
    }
    module2.exports = function parse9(all4, queries) {
      if (!Array.isArray(queries))
        queries = [queries];
      return flatten(
        queries.map(function(block) {
          var qs = [];
          do {
            block = matchBlock(all4, block, qs);
          } while (block);
          return qs;
        })
      );
    };
  }
});

// node_modules/caniuse-lite/dist/lib/statuses.js
var require_statuses = __commonJS({
  "node_modules/caniuse-lite/dist/lib/statuses.js"(exports, module2) {
    module2.exports = {
      1: "ls",
      // WHATWG Living Standard
      2: "rec",
      // W3C Recommendation
      3: "pr",
      // W3C Proposed Recommendation
      4: "cr",
      // W3C Candidate Recommendation
      5: "wd",
      // W3C Working Draft
      6: "other",
      // Non-W3C, but reputable
      7: "unoff"
      // Unofficial, Editor's Draft or W3C "Note"
    };
  }
});

// node_modules/caniuse-lite/dist/lib/supported.js
var require_supported = __commonJS({
  "node_modules/caniuse-lite/dist/lib/supported.js"(exports, module2) {
    module2.exports = {
      y: 1 << 0,
      n: 1 << 1,
      a: 1 << 2,
      p: 1 << 3,
      u: 1 << 4,
      x: 1 << 5,
      d: 1 << 6
    };
  }
});

// node_modules/caniuse-lite/dist/unpacker/feature.js
var require_feature = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/feature.js"(exports, module2) {
    "use strict";
    var statuses = require_statuses();
    var supported = require_supported();
    var browsers = require_browsers2().browsers;
    var versions = require_browserVersions2().browserVersions;
    var MATH2LOG = Math.log(2);
    function unpackSupport(cipher) {
      let stats = Object.keys(supported).reduce((list3, support) => {
        if (cipher & supported[support])
          list3.push(support);
        return list3;
      }, []);
      let notes = cipher >> 7;
      let notesArray = [];
      while (notes) {
        let note = Math.floor(Math.log(notes) / MATH2LOG) + 1;
        notesArray.unshift(`#${note}`);
        notes -= Math.pow(2, note - 1);
      }
      return stats.concat(notesArray).join(" ");
    }
    function unpackFeature(packed) {
      let unpacked = { status: statuses[packed.B], title: packed.C };
      unpacked.stats = Object.keys(packed.A).reduce((browserStats, key2) => {
        let browser = packed.A[key2];
        browserStats[browsers[key2]] = Object.keys(browser).reduce(
          (stats, support) => {
            let packedVersions = browser[support].split(" ");
            let unpacked2 = unpackSupport(support);
            packedVersions.forEach((v) => stats[versions[v]] = unpacked2);
            return stats;
          },
          {}
        );
        return browserStats;
      }, {});
      return unpacked;
    }
    module2.exports = unpackFeature;
    module2.exports.default = unpackFeature;
  }
});

// node_modules/caniuse-lite/dist/unpacker/region.js
var require_region = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/region.js"(exports, module2) {
    "use strict";
    var browsers = require_browsers2().browsers;
    function unpackRegion(packed) {
      return Object.keys(packed).reduce((list3, browser) => {
        let data3 = packed[browser];
        list3[browsers[browser]] = Object.keys(data3).reduce((memo, key2) => {
          let stats = data3[key2];
          if (key2 === "_") {
            stats.split(" ").forEach((version3) => memo[version3] = null);
          } else {
            memo[key2] = stats;
          }
          return memo;
        }, {});
        return list3;
      }, {});
    }
    module2.exports = unpackRegion;
    module2.exports.default = unpackRegion;
  }
});

// node_modules/browserslist/node.js
var require_node3 = __commonJS({
  "node_modules/browserslist/node.js"(exports, module2) {
    var feature = require_feature().default;
    var region = require_region().default;
    var path = require("path");
    var fs = require("fs");
    var BrowserslistError = require_error();
    var IS_SECTION = /^\s*\[(.+)]\s*$/;
    var CONFIG_PATTERN = /^browserslist-config-/;
    var SCOPED_CONFIG__PATTERN = /@[^/]+\/browserslist-config(-|$|\/)/;
    var TIME_TO_UPDATE_CANIUSE = 6 * 30 * 24 * 60 * 60 * 1e3;
    var FORMAT = "Browserslist config should be a string or an array of strings with browser queries";
    var dataTimeChecked = false;
    var filenessCache = {};
    var configCache = {};
    function checkExtend(name2) {
      var use = " Use `dangerousExtend` option to disable.";
      if (!CONFIG_PATTERN.test(name2) && !SCOPED_CONFIG__PATTERN.test(name2)) {
        throw new BrowserslistError(
          "Browserslist config needs `browserslist-config-` prefix. " + use
        );
      }
      if (name2.replace(/^@[^/]+\//, "").indexOf(".") !== -1) {
        throw new BrowserslistError(
          "`.` not allowed in Browserslist config name. " + use
        );
      }
      if (name2.indexOf("node_modules") !== -1) {
        throw new BrowserslistError(
          "`node_modules` not allowed in Browserslist config." + use
        );
      }
    }
    function isFile(file) {
      if (file in filenessCache) {
        return filenessCache[file];
      }
      var result = fs.existsSync(file) && fs.statSync(file).isFile();
      if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
        filenessCache[file] = result;
      }
      return result;
    }
    function eachParent(file, callback) {
      var dir = isFile(file) ? path.dirname(file) : file;
      var loc = path.resolve(dir);
      do {
        var result = callback(loc);
        if (typeof result !== "undefined")
          return result;
      } while (loc !== (loc = path.dirname(loc)));
      return void 0;
    }
    function check(section) {
      if (Array.isArray(section)) {
        for (var i = 0; i < section.length; i++) {
          if (typeof section[i] !== "string") {
            throw new BrowserslistError(FORMAT);
          }
        }
      } else if (typeof section !== "string") {
        throw new BrowserslistError(FORMAT);
      }
    }
    function pickEnv(config, opts) {
      if (typeof config !== "object")
        return config;
      var name2;
      if (typeof opts.env === "string") {
        name2 = opts.env;
      } else if (process.env.BROWSERSLIST_ENV) {
        name2 = process.env.BROWSERSLIST_ENV;
      } else if (process.env.NODE_ENV) {
        name2 = process.env.NODE_ENV;
      } else {
        name2 = "production";
      }
      if (opts.throwOnMissing) {
        if (name2 && name2 !== "defaults" && !config[name2]) {
          throw new BrowserslistError(
            "Missing config for Browserslist environment `" + name2 + "`"
          );
        }
      }
      return config[name2] || config.defaults;
    }
    function parsePackage(file) {
      var config = JSON.parse(
        fs.readFileSync(file).toString().replace(/^\uFEFF/m, "")
      );
      if (config.browserlist && !config.browserslist) {
        throw new BrowserslistError(
          "`browserlist` key instead of `browserslist` in " + file
        );
      }
      var list3 = config.browserslist;
      if (Array.isArray(list3) || typeof list3 === "string") {
        list3 = { defaults: list3 };
      }
      for (var i in list3) {
        check(list3[i]);
      }
      return list3;
    }
    function latestReleaseTime(agents) {
      var latest = 0;
      for (var name2 in agents) {
        var dates = agents[name2].releaseDate || {};
        for (var key2 in dates) {
          if (latest < dates[key2]) {
            latest = dates[key2];
          }
        }
      }
      return latest * 1e3;
    }
    function normalizeStats(data3, stats) {
      if (!data3) {
        data3 = {};
      }
      if (stats && "dataByBrowser" in stats) {
        stats = stats.dataByBrowser;
      }
      if (typeof stats !== "object")
        return void 0;
      var normalized = {};
      for (var i in stats) {
        var versions = Object.keys(stats[i]);
        if (versions.length === 1 && data3[i] && data3[i].versions.length === 1) {
          var normal = data3[i].versions[0];
          normalized[i] = {};
          normalized[i][normal] = stats[i][versions[0]];
        } else {
          normalized[i] = stats[i];
        }
      }
      return normalized;
    }
    function normalizeUsageData(usageData, data3) {
      for (var browser in usageData) {
        var browserUsage = usageData[browser];
        if ("0" in browserUsage) {
          var versions = data3[browser].versions;
          browserUsage[versions[versions.length - 1]] = browserUsage[0];
          delete browserUsage[0];
        }
      }
    }
    module2.exports = {
      loadQueries: function loadQueries(ctx, name2) {
        if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
          checkExtend(name2);
        }
        var queries = require(require.resolve(name2, { paths: [".", ctx.path] }));
        if (queries) {
          if (Array.isArray(queries)) {
            return queries;
          } else if (typeof queries === "object") {
            if (!queries.defaults)
              queries.defaults = [];
            return pickEnv(queries, ctx, name2);
          }
        }
        throw new BrowserslistError(
          "`" + name2 + "` config exports not an array of queries or an object of envs"
        );
      },
      loadStat: function loadStat(ctx, name2, data3) {
        if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
          checkExtend(name2);
        }
        var stats = require(require.resolve(
          path.join(name2, "browserslist-stats.json"),
          { paths: ["."] }
        ));
        return normalizeStats(data3, stats);
      },
      getStat: function getStat(opts, data3) {
        var stats;
        if (opts.stats) {
          stats = opts.stats;
        } else if (process.env.BROWSERSLIST_STATS) {
          stats = process.env.BROWSERSLIST_STATS;
        } else if (opts.path && path.resolve && fs.existsSync) {
          stats = eachParent(opts.path, function(dir) {
            var file = path.join(dir, "browserslist-stats.json");
            return isFile(file) ? file : void 0;
          });
        }
        if (typeof stats === "string") {
          try {
            stats = JSON.parse(fs.readFileSync(stats));
          } catch (e) {
            throw new BrowserslistError("Can't read " + stats);
          }
        }
        return normalizeStats(data3, stats);
      },
      loadConfig: function loadConfig(opts) {
        if (process.env.BROWSERSLIST) {
          return process.env.BROWSERSLIST;
        } else if (opts.config || process.env.BROWSERSLIST_CONFIG) {
          var file = opts.config || process.env.BROWSERSLIST_CONFIG;
          if (path.basename(file) === "package.json") {
            return pickEnv(parsePackage(file), opts);
          } else {
            return pickEnv(module2.exports.readConfig(file), opts);
          }
        } else if (opts.path) {
          return pickEnv(module2.exports.findConfig(opts.path), opts);
        } else {
          return void 0;
        }
      },
      loadCountry: function loadCountry(usage, country, data3) {
        var code2 = country.replace(/[^\w-]/g, "");
        if (!usage[code2]) {
          var compressed;
          try {
            compressed = require("caniuse-lite/data/regions/" + code2 + ".js");
          } catch (e) {
            throw new BrowserslistError("Unknown region name `" + code2 + "`.");
          }
          var usageData = region(compressed);
          normalizeUsageData(usageData, data3);
          usage[country] = {};
          for (var i in usageData) {
            for (var j in usageData[i]) {
              usage[country][i + " " + j] = usageData[i][j];
            }
          }
        }
      },
      loadFeature: function loadFeature(features, name2) {
        name2 = name2.replace(/[^\w-]/g, "");
        if (features[name2])
          return;
        var compressed;
        try {
          compressed = require("caniuse-lite/data/features/" + name2 + ".js");
        } catch (e) {
          throw new BrowserslistError("Unknown feature name `" + name2 + "`.");
        }
        var stats = feature(compressed).stats;
        features[name2] = {};
        for (var i in stats) {
          for (var j in stats[i]) {
            features[name2][i + " " + j] = stats[i][j];
          }
        }
      },
      parseConfig: function parseConfig(string3) {
        var result = { defaults: [] };
        var sections = ["defaults"];
        string3.toString().replace(/#[^\n]*/g, "").split(/\n|,/).map(function(line2) {
          return line2.trim();
        }).filter(function(line2) {
          return line2 !== "";
        }).forEach(function(line2) {
          if (IS_SECTION.test(line2)) {
            sections = line2.match(IS_SECTION)[1].trim().split(" ");
            sections.forEach(function(section) {
              if (result[section]) {
                throw new BrowserslistError(
                  "Duplicate section " + section + " in Browserslist config"
                );
              }
              result[section] = [];
            });
          } else {
            sections.forEach(function(section) {
              result[section].push(line2);
            });
          }
        });
        return result;
      },
      readConfig: function readConfig(file) {
        if (!isFile(file)) {
          throw new BrowserslistError("Can't read " + file + " config");
        }
        return module2.exports.parseConfig(fs.readFileSync(file));
      },
      findConfig: function findConfig(from) {
        from = path.resolve(from);
        var passed = [];
        var resolved = eachParent(from, function(dir) {
          if (dir in configCache) {
            return configCache[dir];
          }
          passed.push(dir);
          var config = path.join(dir, "browserslist");
          var pkg = path.join(dir, "package.json");
          var rc = path.join(dir, ".browserslistrc");
          var pkgBrowserslist;
          if (isFile(pkg)) {
            try {
              pkgBrowserslist = parsePackage(pkg);
            } catch (e) {
              if (e.name === "BrowserslistError")
                throw e;
              console.warn(
                "[Browserslist] Could not parse " + pkg + ". Ignoring it."
              );
            }
          }
          if (isFile(config) && pkgBrowserslist) {
            throw new BrowserslistError(
              dir + " contains both browserslist and package.json with browsers"
            );
          } else if (isFile(rc) && pkgBrowserslist) {
            throw new BrowserslistError(
              dir + " contains both .browserslistrc and package.json with browsers"
            );
          } else if (isFile(config) && isFile(rc)) {
            throw new BrowserslistError(
              dir + " contains both .browserslistrc and browserslist"
            );
          } else if (isFile(config)) {
            return module2.exports.readConfig(config);
          } else if (isFile(rc)) {
            return module2.exports.readConfig(rc);
          } else {
            return pkgBrowserslist;
          }
        });
        if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
          passed.forEach(function(dir) {
            configCache[dir] = resolved;
          });
        }
        return resolved;
      },
      clearCaches: function clearCaches() {
        dataTimeChecked = false;
        filenessCache = {};
        configCache = {};
        this.cache = {};
      },
      oldDataWarning: function oldDataWarning(agentsObj) {
        if (dataTimeChecked)
          return;
        dataTimeChecked = true;
        if (process.env.BROWSERSLIST_IGNORE_OLD_DATA)
          return;
        var latest = latestReleaseTime(agentsObj);
        var halfYearAgo = Date.now() - TIME_TO_UPDATE_CANIUSE;
        if (latest !== 0 && latest < halfYearAgo) {
          console.warn(
            "Browserslist: caniuse-lite is outdated. Please run:\n  npx update-browserslist-db@latest\n  Why you should do it regularly: https://github.com/browserslist/update-db#readme"
          );
        }
      },
      currentNode: function currentNode() {
        return "node " + process.versions.node;
      },
      env: process.env
    };
  }
});

// node_modules/browserslist/index.js
var require_browserslist = __commonJS({
  "node_modules/browserslist/index.js"(exports, module2) {
    var jsReleases = require_envs();
    var agents = require_agents2().agents;
    var jsEOL = require_release_schedule();
    var path = require("path");
    var e2c = require_versions();
    var BrowserslistError = require_error();
    var parse9 = require_parse2();
    var env = require_node3();
    var YEAR = 365.259641 * 24 * 60 * 60 * 1e3;
    var ANDROID_EVERGREEN_FIRST = 37;
    function isVersionsMatch(versionA, versionB) {
      return (versionA + ".").indexOf(versionB + ".") === 0;
    }
    function isEolReleased(name2) {
      var version3 = name2.slice(1);
      return browserslist.nodeVersions.some(function(i) {
        return isVersionsMatch(i, version3);
      });
    }
    function normalize2(versions) {
      return versions.filter(function(version3) {
        return typeof version3 === "string";
      });
    }
    function normalizeElectron(version3) {
      var versionToUse = version3;
      if (version3.split(".").length === 3) {
        versionToUse = version3.split(".").slice(0, -1).join(".");
      }
      return versionToUse;
    }
    function nameMapper(name2) {
      return function mapName(version3) {
        return name2 + " " + version3;
      };
    }
    function getMajor(version3) {
      return parseInt(version3.split(".")[0]);
    }
    function getMajorVersions(released, number2) {
      if (released.length === 0)
        return [];
      var majorVersions = uniq(released.map(getMajor));
      var minimum = majorVersions[majorVersions.length - number2];
      if (!minimum) {
        return released;
      }
      var selected = [];
      for (var i = released.length - 1; i >= 0; i--) {
        if (minimum > getMajor(released[i]))
          break;
        selected.unshift(released[i]);
      }
      return selected;
    }
    function uniq(array) {
      var filtered = [];
      for (var i = 0; i < array.length; i++) {
        if (filtered.indexOf(array[i]) === -1)
          filtered.push(array[i]);
      }
      return filtered;
    }
    function fillUsage(result, name2, data3) {
      for (var i in data3) {
        result[name2 + " " + i] = data3[i];
      }
    }
    function generateFilter(sign2, version3) {
      version3 = parseFloat(version3);
      if (sign2 === ">") {
        return function(v) {
          return parseFloat(v) > version3;
        };
      } else if (sign2 === ">=") {
        return function(v) {
          return parseFloat(v) >= version3;
        };
      } else if (sign2 === "<") {
        return function(v) {
          return parseFloat(v) < version3;
        };
      } else {
        return function(v) {
          return parseFloat(v) <= version3;
        };
      }
    }
    function generateSemverFilter(sign2, version3) {
      version3 = version3.split(".").map(parseSimpleInt);
      version3[1] = version3[1] || 0;
      version3[2] = version3[2] || 0;
      if (sign2 === ">") {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(v, version3) > 0;
        };
      } else if (sign2 === ">=") {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(v, version3) >= 0;
        };
      } else if (sign2 === "<") {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(version3, v) > 0;
        };
      } else {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(version3, v) >= 0;
        };
      }
    }
    function parseSimpleInt(x) {
      return parseInt(x);
    }
    function compare2(a, b) {
      if (a < b)
        return -1;
      if (a > b)
        return 1;
      return 0;
    }
    function compareSemver(a, b) {
      return compare2(parseInt(a[0]), parseInt(b[0])) || compare2(parseInt(a[1] || "0"), parseInt(b[1] || "0")) || compare2(parseInt(a[2] || "0"), parseInt(b[2] || "0"));
    }
    function semverFilterLoose(operator, range) {
      range = range.split(".").map(parseSimpleInt);
      if (typeof range[1] === "undefined") {
        range[1] = "x";
      }
      switch (operator) {
        case "<=":
          return function(version3) {
            version3 = version3.split(".").map(parseSimpleInt);
            return compareSemverLoose(version3, range) <= 0;
          };
        case ">=":
        default:
          return function(version3) {
            version3 = version3.split(".").map(parseSimpleInt);
            return compareSemverLoose(version3, range) >= 0;
          };
      }
    }
    function compareSemverLoose(version3, range) {
      if (version3[0] !== range[0]) {
        return version3[0] < range[0] ? -1 : 1;
      }
      if (range[1] === "x") {
        return 0;
      }
      if (version3[1] !== range[1]) {
        return version3[1] < range[1] ? -1 : 1;
      }
      return 0;
    }
    function resolveVersion(data3, version3) {
      if (data3.versions.indexOf(version3) !== -1) {
        return version3;
      } else if (browserslist.versionAliases[data3.name][version3]) {
        return browserslist.versionAliases[data3.name][version3];
      } else {
        return false;
      }
    }
    function normalizeVersion(data3, version3) {
      var resolved = resolveVersion(data3, version3);
      if (resolved) {
        return resolved;
      } else if (data3.versions.length === 1) {
        return data3.versions[0];
      } else {
        return false;
      }
    }
    function filterByYear(since, context) {
      since = since / 1e3;
      return Object.keys(agents).reduce(function(selected, name2) {
        var data3 = byName(name2, context);
        if (!data3)
          return selected;
        var versions = Object.keys(data3.releaseDate).filter(function(v) {
          var date = data3.releaseDate[v];
          return date !== null && date >= since;
        });
        return selected.concat(versions.map(nameMapper(data3.name)));
      }, []);
    }
    function cloneData(data3) {
      return {
        name: data3.name,
        versions: data3.versions,
        released: data3.released,
        releaseDate: data3.releaseDate
      };
    }
    function mapVersions(data3, map) {
      data3.versions = data3.versions.map(function(i2) {
        return map[i2] || i2;
      });
      data3.released = data3.released.map(function(i2) {
        return map[i2] || i2;
      });
      var fixedDate = {};
      for (var i in data3.releaseDate) {
        fixedDate[map[i] || i] = data3.releaseDate[i];
      }
      data3.releaseDate = fixedDate;
      return data3;
    }
    function byName(name2, context) {
      name2 = name2.toLowerCase();
      name2 = browserslist.aliases[name2] || name2;
      if (context.mobileToDesktop && browserslist.desktopNames[name2]) {
        var desktop = browserslist.data[browserslist.desktopNames[name2]];
        if (name2 === "android") {
          return normalizeAndroidData(cloneData(browserslist.data[name2]), desktop);
        } else {
          var cloned = cloneData(desktop);
          cloned.name = name2;
          if (name2 === "op_mob") {
            cloned = mapVersions(cloned, { "10.0-10.1": "10" });
          }
          return cloned;
        }
      }
      return browserslist.data[name2];
    }
    function normalizeAndroidVersions(androidVersions, chromeVersions) {
      var firstEvergreen = ANDROID_EVERGREEN_FIRST;
      var last = chromeVersions[chromeVersions.length - 1];
      return androidVersions.filter(function(version3) {
        return /^(?:[2-4]\.|[34]$)/.test(version3);
      }).concat(chromeVersions.slice(firstEvergreen - last - 1));
    }
    function normalizeAndroidData(android, chrome) {
      android.released = normalizeAndroidVersions(android.released, chrome.released);
      android.versions = normalizeAndroidVersions(android.versions, chrome.versions);
      return android;
    }
    function checkName(name2, context) {
      var data3 = byName(name2, context);
      if (!data3)
        throw new BrowserslistError("Unknown browser " + name2);
      return data3;
    }
    function unknownQuery(query) {
      return new BrowserslistError(
        "Unknown browser query `" + query + "`. Maybe you are using old Browserslist or made typo in query."
      );
    }
    function filterAndroid(list3, versions, context) {
      if (context.mobileToDesktop)
        return list3;
      var released = browserslist.data.android.released;
      var last = released[released.length - 1];
      var diff = last - ANDROID_EVERGREEN_FIRST - versions;
      if (diff > 0) {
        return list3.slice(-1);
      } else {
        return list3.slice(diff - 1);
      }
    }
    function resolve(queries, context) {
      return parse9(QUERIES, queries).reduce(function(result, node2, index2) {
        if (node2.not && index2 === 0) {
          throw new BrowserslistError(
            "Write any browsers query (for instance, `defaults`) before `" + node2.query + "`"
          );
        }
        var type = QUERIES[node2.type];
        var array = type.select.call(browserslist, context, node2).map(function(j) {
          var parts = j.split(" ");
          if (parts[1] === "0") {
            return parts[0] + " " + byName(parts[0], context).versions[0];
          } else {
            return j;
          }
        });
        if (node2.compose === "and") {
          if (node2.not) {
            return result.filter(function(j) {
              return array.indexOf(j) === -1;
            });
          } else {
            return result.filter(function(j) {
              return array.indexOf(j) !== -1;
            });
          }
        } else {
          if (node2.not) {
            var filter = {};
            array.forEach(function(j) {
              filter[j] = true;
            });
            return result.filter(function(j) {
              return !filter[j];
            });
          }
          return result.concat(array);
        }
      }, []);
    }
    function prepareOpts(opts) {
      if (typeof opts === "undefined")
        opts = {};
      if (typeof opts.path === "undefined") {
        opts.path = path.resolve ? path.resolve(".") : ".";
      }
      return opts;
    }
    function prepareQueries(queries, opts) {
      if (typeof queries === "undefined" || queries === null) {
        var config = browserslist.loadConfig(opts);
        if (config) {
          queries = config;
        } else {
          queries = browserslist.defaults;
        }
      }
      return queries;
    }
    function checkQueries(queries) {
      if (!(typeof queries === "string" || Array.isArray(queries))) {
        throw new BrowserslistError(
          "Browser queries must be an array or string. Got " + typeof queries + "."
        );
      }
    }
    var cache = {};
    function browserslist(queries, opts) {
      opts = prepareOpts(opts);
      queries = prepareQueries(queries, opts);
      checkQueries(queries);
      var context = {
        ignoreUnknownVersions: opts.ignoreUnknownVersions,
        dangerousExtend: opts.dangerousExtend,
        mobileToDesktop: opts.mobileToDesktop,
        path: opts.path,
        env: opts.env
      };
      env.oldDataWarning(browserslist.data);
      var stats = env.getStat(opts, browserslist.data);
      if (stats) {
        context.customUsage = {};
        for (var browser in stats) {
          fillUsage(context.customUsage, browser, stats[browser]);
        }
      }
      var cacheKey = JSON.stringify([queries, context]);
      if (cache[cacheKey])
        return cache[cacheKey];
      var result = uniq(resolve(queries, context)).sort(function(name1, name2) {
        name1 = name1.split(" ");
        name2 = name2.split(" ");
        if (name1[0] === name2[0]) {
          var version1 = name1[1].split("-")[0];
          var version22 = name2[1].split("-")[0];
          return compareSemver(version22.split("."), version1.split("."));
        } else {
          return compare2(name1[0], name2[0]);
        }
      });
      if (!env.env.BROWSERSLIST_DISABLE_CACHE) {
        cache[cacheKey] = result;
      }
      return result;
    }
    browserslist.parse = function(queries, opts) {
      opts = prepareOpts(opts);
      queries = prepareQueries(queries, opts);
      checkQueries(queries);
      return parse9(QUERIES, queries);
    };
    browserslist.cache = {};
    browserslist.data = {};
    browserslist.usage = {
      global: {},
      custom: null
    };
    browserslist.defaults = ["> 0.5%", "last 2 versions", "Firefox ESR", "not dead"];
    browserslist.aliases = {
      fx: "firefox",
      ff: "firefox",
      ios: "ios_saf",
      explorer: "ie",
      blackberry: "bb",
      explorermobile: "ie_mob",
      operamini: "op_mini",
      operamobile: "op_mob",
      chromeandroid: "and_chr",
      firefoxandroid: "and_ff",
      ucandroid: "and_uc",
      qqandroid: "and_qq"
    };
    browserslist.desktopNames = {
      and_chr: "chrome",
      and_ff: "firefox",
      ie_mob: "ie",
      op_mob: "opera",
      android: "chrome"
      // has extra processing logic
    };
    browserslist.versionAliases = {};
    browserslist.clearCaches = env.clearCaches;
    browserslist.parseConfig = env.parseConfig;
    browserslist.readConfig = env.readConfig;
    browserslist.findConfig = env.findConfig;
    browserslist.loadConfig = env.loadConfig;
    browserslist.coverage = function(browsers, stats) {
      var data3;
      if (typeof stats === "undefined") {
        data3 = browserslist.usage.global;
      } else if (stats === "my stats") {
        var opts = {};
        opts.path = path.resolve ? path.resolve(".") : ".";
        var customStats = env.getStat(opts);
        if (!customStats) {
          throw new BrowserslistError("Custom usage statistics was not provided");
        }
        data3 = {};
        for (var browser in customStats) {
          fillUsage(data3, browser, customStats[browser]);
        }
      } else if (typeof stats === "string") {
        if (stats.length > 2) {
          stats = stats.toLowerCase();
        } else {
          stats = stats.toUpperCase();
        }
        env.loadCountry(browserslist.usage, stats, browserslist.data);
        data3 = browserslist.usage[stats];
      } else {
        if ("dataByBrowser" in stats) {
          stats = stats.dataByBrowser;
        }
        data3 = {};
        for (var name2 in stats) {
          for (var version3 in stats[name2]) {
            data3[name2 + " " + version3] = stats[name2][version3];
          }
        }
      }
      return browsers.reduce(function(all4, i) {
        var usage = data3[i];
        if (usage === void 0) {
          usage = data3[i.replace(/ \S+$/, " 0")];
        }
        return all4 + (usage || 0);
      }, 0);
    };
    function nodeQuery(context, node2) {
      var matched = browserslist.nodeVersions.filter(function(i) {
        return isVersionsMatch(i, node2.version);
      });
      if (matched.length === 0) {
        if (context.ignoreUnknownVersions) {
          return [];
        } else {
          throw new BrowserslistError(
            "Unknown version " + node2.version + " of Node.js"
          );
        }
      }
      return ["node " + matched[matched.length - 1]];
    }
    function sinceQuery(context, node2) {
      var year = parseInt(node2.year);
      var month = parseInt(node2.month || "01") - 1;
      var day = parseInt(node2.day || "01");
      return filterByYear(Date.UTC(year, month, day, 0, 0, 0), context);
    }
    function coverQuery(context, node2) {
      var coverage = parseFloat(node2.coverage);
      var usage = browserslist.usage.global;
      if (node2.place) {
        if (node2.place.match(/^my\s+stats$/i)) {
          if (!context.customUsage) {
            throw new BrowserslistError("Custom usage statistics was not provided");
          }
          usage = context.customUsage;
        } else {
          var place;
          if (node2.place.length === 2) {
            place = node2.place.toUpperCase();
          } else {
            place = node2.place.toLowerCase();
          }
          env.loadCountry(browserslist.usage, place, browserslist.data);
          usage = browserslist.usage[place];
        }
      }
      var versions = Object.keys(usage).sort(function(a, b) {
        return usage[b] - usage[a];
      });
      var coveraged = 0;
      var result = [];
      var version3;
      for (var i = 0; i < versions.length; i++) {
        version3 = versions[i];
        if (usage[version3] === 0)
          break;
        coveraged += usage[version3];
        result.push(version3);
        if (coveraged >= coverage)
          break;
      }
      return result;
    }
    var QUERIES = {
      last_major_versions: {
        matches: ["versions"],
        regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
        select: function(context, node2) {
          return Object.keys(agents).reduce(function(selected, name2) {
            var data3 = byName(name2, context);
            if (!data3)
              return selected;
            var list3 = getMajorVersions(data3.released, node2.versions);
            list3 = list3.map(nameMapper(data3.name));
            if (data3.name === "android") {
              list3 = filterAndroid(list3, node2.versions, context);
            }
            return selected.concat(list3);
          }, []);
        }
      },
      last_versions: {
        matches: ["versions"],
        regexp: /^last\s+(\d+)\s+versions?$/i,
        select: function(context, node2) {
          return Object.keys(agents).reduce(function(selected, name2) {
            var data3 = byName(name2, context);
            if (!data3)
              return selected;
            var list3 = data3.released.slice(-node2.versions);
            list3 = list3.map(nameMapper(data3.name));
            if (data3.name === "android") {
              list3 = filterAndroid(list3, node2.versions, context);
            }
            return selected.concat(list3);
          }, []);
        }
      },
      last_electron_major_versions: {
        matches: ["versions"],
        regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
        select: function(context, node2) {
          var validVersions = getMajorVersions(Object.keys(e2c), node2.versions);
          return validVersions.map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      last_node_major_versions: {
        matches: ["versions"],
        regexp: /^last\s+(\d+)\s+node\s+major\s+versions?$/i,
        select: function(context, node2) {
          return getMajorVersions(browserslist.nodeVersions, node2.versions).map(
            function(version3) {
              return "node " + version3;
            }
          );
        }
      },
      last_browser_major_versions: {
        matches: ["versions", "browser"],
        regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
        select: function(context, node2) {
          var data3 = checkName(node2.browser, context);
          var validVersions = getMajorVersions(data3.released, node2.versions);
          var list3 = validVersions.map(nameMapper(data3.name));
          if (data3.name === "android") {
            list3 = filterAndroid(list3, node2.versions, context);
          }
          return list3;
        }
      },
      last_electron_versions: {
        matches: ["versions"],
        regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
        select: function(context, node2) {
          return Object.keys(e2c).slice(-node2.versions).map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      last_node_versions: {
        matches: ["versions"],
        regexp: /^last\s+(\d+)\s+node\s+versions?$/i,
        select: function(context, node2) {
          return browserslist.nodeVersions.slice(-node2.versions).map(function(version3) {
            return "node " + version3;
          });
        }
      },
      last_browser_versions: {
        matches: ["versions", "browser"],
        regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
        select: function(context, node2) {
          var data3 = checkName(node2.browser, context);
          var list3 = data3.released.slice(-node2.versions).map(nameMapper(data3.name));
          if (data3.name === "android") {
            list3 = filterAndroid(list3, node2.versions, context);
          }
          return list3;
        }
      },
      unreleased_versions: {
        matches: [],
        regexp: /^unreleased\s+versions$/i,
        select: function(context) {
          return Object.keys(agents).reduce(function(selected, name2) {
            var data3 = byName(name2, context);
            if (!data3)
              return selected;
            var list3 = data3.versions.filter(function(v) {
              return data3.released.indexOf(v) === -1;
            });
            list3 = list3.map(nameMapper(data3.name));
            return selected.concat(list3);
          }, []);
        }
      },
      unreleased_electron_versions: {
        matches: [],
        regexp: /^unreleased\s+electron\s+versions?$/i,
        select: function() {
          return [];
        }
      },
      unreleased_browser_versions: {
        matches: ["browser"],
        regexp: /^unreleased\s+(\w+)\s+versions?$/i,
        select: function(context, node2) {
          var data3 = checkName(node2.browser, context);
          return data3.versions.filter(function(v) {
            return data3.released.indexOf(v) === -1;
          }).map(nameMapper(data3.name));
        }
      },
      last_years: {
        matches: ["years"],
        regexp: /^last\s+(\d*.?\d+)\s+years?$/i,
        select: function(context, node2) {
          return filterByYear(Date.now() - YEAR * node2.years, context);
        }
      },
      since_y: {
        matches: ["year"],
        regexp: /^since (\d+)$/i,
        select: sinceQuery
      },
      since_y_m: {
        matches: ["year", "month"],
        regexp: /^since (\d+)-(\d+)$/i,
        select: sinceQuery
      },
      since_y_m_d: {
        matches: ["year", "month", "day"],
        regexp: /^since (\d+)-(\d+)-(\d+)$/i,
        select: sinceQuery
      },
      popularity: {
        matches: ["sign", "popularity"],
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/,
        select: function(context, node2) {
          var popularity = parseFloat(node2.popularity);
          var usage = browserslist.usage.global;
          return Object.keys(usage).reduce(function(result, version3) {
            if (node2.sign === ">") {
              if (usage[version3] > popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<") {
              if (usage[version3] < popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<=") {
              if (usage[version3] <= popularity) {
                result.push(version3);
              }
            } else if (usage[version3] >= popularity) {
              result.push(version3);
            }
            return result;
          }, []);
        }
      },
      popularity_in_my_stats: {
        matches: ["sign", "popularity"],
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/,
        select: function(context, node2) {
          var popularity = parseFloat(node2.popularity);
          if (!context.customUsage) {
            throw new BrowserslistError("Custom usage statistics was not provided");
          }
          var usage = context.customUsage;
          return Object.keys(usage).reduce(function(result, version3) {
            var percentage = usage[version3];
            if (percentage == null) {
              return result;
            }
            if (node2.sign === ">") {
              if (percentage > popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<") {
              if (percentage < popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<=") {
              if (percentage <= popularity) {
                result.push(version3);
              }
            } else if (percentage >= popularity) {
              result.push(version3);
            }
            return result;
          }, []);
        }
      },
      popularity_in_config_stats: {
        matches: ["sign", "popularity", "config"],
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/,
        select: function(context, node2) {
          var popularity = parseFloat(node2.popularity);
          var stats = env.loadStat(context, node2.config, browserslist.data);
          if (stats) {
            context.customUsage = {};
            for (var browser in stats) {
              fillUsage(context.customUsage, browser, stats[browser]);
            }
          }
          if (!context.customUsage) {
            throw new BrowserslistError("Custom usage statistics was not provided");
          }
          var usage = context.customUsage;
          return Object.keys(usage).reduce(function(result, version3) {
            var percentage = usage[version3];
            if (percentage == null) {
              return result;
            }
            if (node2.sign === ">") {
              if (percentage > popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<") {
              if (percentage < popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<=") {
              if (percentage <= popularity) {
                result.push(version3);
              }
            } else if (percentage >= popularity) {
              result.push(version3);
            }
            return result;
          }, []);
        }
      },
      popularity_in_place: {
        matches: ["sign", "popularity", "place"],
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/,
        select: function(context, node2) {
          var popularity = parseFloat(node2.popularity);
          var place = node2.place;
          if (place.length === 2) {
            place = place.toUpperCase();
          } else {
            place = place.toLowerCase();
          }
          env.loadCountry(browserslist.usage, place, browserslist.data);
          var usage = browserslist.usage[place];
          return Object.keys(usage).reduce(function(result, version3) {
            var percentage = usage[version3];
            if (percentage == null) {
              return result;
            }
            if (node2.sign === ">") {
              if (percentage > popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<") {
              if (percentage < popularity) {
                result.push(version3);
              }
            } else if (node2.sign === "<=") {
              if (percentage <= popularity) {
                result.push(version3);
              }
            } else if (percentage >= popularity) {
              result.push(version3);
            }
            return result;
          }, []);
        }
      },
      cover: {
        matches: ["coverage"],
        regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/i,
        select: coverQuery
      },
      cover_in: {
        matches: ["coverage", "place"],
        regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/i,
        select: coverQuery
      },
      supports: {
        matches: ["feature"],
        regexp: /^supports\s+([\w-]+)$/,
        select: function(context, node2) {
          env.loadFeature(browserslist.cache, node2.feature);
          var features = browserslist.cache[node2.feature];
          return Object.keys(features).reduce(function(result, version3) {
            var flags = features[version3];
            if (flags.indexOf("y") >= 0 || flags.indexOf("a") >= 0) {
              result.push(version3);
            }
            return result;
          }, []);
        }
      },
      electron_range: {
        matches: ["from", "to"],
        regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
        select: function(context, node2) {
          var fromToUse = normalizeElectron(node2.from);
          var toToUse = normalizeElectron(node2.to);
          var from = parseFloat(node2.from);
          var to = parseFloat(node2.to);
          if (!e2c[fromToUse]) {
            throw new BrowserslistError("Unknown version " + from + " of electron");
          }
          if (!e2c[toToUse]) {
            throw new BrowserslistError("Unknown version " + to + " of electron");
          }
          return Object.keys(e2c).filter(function(i) {
            var parsed = parseFloat(i);
            return parsed >= from && parsed <= to;
          }).map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      node_range: {
        matches: ["from", "to"],
        regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
        select: function(context, node2) {
          return browserslist.nodeVersions.filter(semverFilterLoose(">=", node2.from)).filter(semverFilterLoose("<=", node2.to)).map(function(v) {
            return "node " + v;
          });
        }
      },
      browser_range: {
        matches: ["browser", "from", "to"],
        regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
        select: function(context, node2) {
          var data3 = checkName(node2.browser, context);
          var from = parseFloat(normalizeVersion(data3, node2.from) || node2.from);
          var to = parseFloat(normalizeVersion(data3, node2.to) || node2.to);
          function filter(v) {
            var parsed = parseFloat(v);
            return parsed >= from && parsed <= to;
          }
          return data3.released.filter(filter).map(nameMapper(data3.name));
        }
      },
      electron_ray: {
        matches: ["sign", "version"],
        regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
        select: function(context, node2) {
          var versionToUse = normalizeElectron(node2.version);
          return Object.keys(e2c).filter(generateFilter(node2.sign, versionToUse)).map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      node_ray: {
        matches: ["sign", "version"],
        regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
        select: function(context, node2) {
          return browserslist.nodeVersions.filter(generateSemverFilter(node2.sign, node2.version)).map(function(v) {
            return "node " + v;
          });
        }
      },
      browser_ray: {
        matches: ["browser", "sign", "version"],
        regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
        select: function(context, node2) {
          var version3 = node2.version;
          var data3 = checkName(node2.browser, context);
          var alias = browserslist.versionAliases[data3.name][version3];
          if (alias)
            version3 = alias;
          return data3.released.filter(generateFilter(node2.sign, version3)).map(function(v) {
            return data3.name + " " + v;
          });
        }
      },
      firefox_esr: {
        matches: [],
        regexp: /^(firefox|ff|fx)\s+esr$/i,
        select: function() {
          return ["firefox 102"];
        }
      },
      opera_mini_all: {
        matches: [],
        regexp: /(operamini|op_mini)\s+all/i,
        select: function() {
          return ["op_mini all"];
        }
      },
      electron_version: {
        matches: ["version"],
        regexp: /^electron\s+([\d.]+)$/i,
        select: function(context, node2) {
          var versionToUse = normalizeElectron(node2.version);
          var chrome = e2c[versionToUse];
          if (!chrome) {
            throw new BrowserslistError(
              "Unknown version " + node2.version + " of electron"
            );
          }
          return ["chrome " + chrome];
        }
      },
      node_major_version: {
        matches: ["version"],
        regexp: /^node\s+(\d+)$/i,
        select: nodeQuery
      },
      node_minor_version: {
        matches: ["version"],
        regexp: /^node\s+(\d+\.\d+)$/i,
        select: nodeQuery
      },
      node_patch_version: {
        matches: ["version"],
        regexp: /^node\s+(\d+\.\d+\.\d+)$/i,
        select: nodeQuery
      },
      current_node: {
        matches: [],
        regexp: /^current\s+node$/i,
        select: function(context) {
          return [env.currentNode(resolve, context)];
        }
      },
      maintained_node: {
        matches: [],
        regexp: /^maintained\s+node\s+versions$/i,
        select: function(context) {
          var now = Date.now();
          var queries = Object.keys(jsEOL).filter(function(key2) {
            return now < Date.parse(jsEOL[key2].end) && now > Date.parse(jsEOL[key2].start) && isEolReleased(key2);
          }).map(function(key2) {
            return "node " + key2.slice(1);
          });
          return resolve(queries, context);
        }
      },
      phantomjs_1_9: {
        matches: [],
        regexp: /^phantomjs\s+1.9$/i,
        select: function() {
          return ["safari 5"];
        }
      },
      phantomjs_2_1: {
        matches: [],
        regexp: /^phantomjs\s+2.1$/i,
        select: function() {
          return ["safari 6"];
        }
      },
      browser_version: {
        matches: ["browser", "version"],
        regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
        select: function(context, node2) {
          var version3 = node2.version;
          if (/^tp$/i.test(version3))
            version3 = "TP";
          var data3 = checkName(node2.browser, context);
          var alias = normalizeVersion(data3, version3);
          if (alias) {
            version3 = alias;
          } else {
            if (version3.indexOf(".") === -1) {
              alias = version3 + ".0";
            } else {
              alias = version3.replace(/\.0$/, "");
            }
            alias = normalizeVersion(data3, alias);
            if (alias) {
              version3 = alias;
            } else if (context.ignoreUnknownVersions) {
              return [];
            } else {
              throw new BrowserslistError(
                "Unknown version " + version3 + " of " + node2.browser
              );
            }
          }
          return [data3.name + " " + version3];
        }
      },
      browserslist_config: {
        matches: [],
        regexp: /^browserslist config$/i,
        select: function(context) {
          return browserslist(void 0, context);
        }
      },
      extends: {
        matches: ["config"],
        regexp: /^extends (.+)$/i,
        select: function(context, node2) {
          return resolve(env.loadQueries(context, node2.config), context);
        }
      },
      defaults: {
        matches: [],
        regexp: /^defaults$/i,
        select: function(context) {
          return resolve(browserslist.defaults, context);
        }
      },
      dead: {
        matches: [],
        regexp: /^dead$/i,
        select: function(context) {
          var dead = [
            "Baidu >= 0",
            "ie <= 11",
            "ie_mob <= 11",
            "bb <= 10",
            "op_mob <= 12.1",
            "samsung 4"
          ];
          return resolve(dead, context);
        }
      },
      unknown: {
        matches: [],
        regexp: /^(\w+)$/i,
        select: function(context, node2) {
          if (byName(node2.query, context)) {
            throw new BrowserslistError(
              "Specify versions in Browserslist query for browser " + node2.query
            );
          } else {
            throw unknownQuery(node2.query);
          }
        }
      }
    };
    (function() {
      for (var name2 in agents) {
        var browser = agents[name2];
        browserslist.data[name2] = {
          name: name2,
          versions: normalize2(agents[name2].versions),
          released: normalize2(agents[name2].versions.slice(0, -3)),
          releaseDate: agents[name2].release_date
        };
        fillUsage(browserslist.usage.global, name2, browser.usage_global);
        browserslist.versionAliases[name2] = {};
        for (var i = 0; i < browser.versions.length; i++) {
          var full = browser.versions[i];
          if (!full)
            continue;
          if (full.indexOf("-") !== -1) {
            var interval = full.split("-");
            for (var j = 0; j < interval.length; j++) {
              browserslist.versionAliases[name2][interval[j]] = full;
            }
          }
        }
      }
      browserslist.versionAliases.op_mob["59"] = "58";
      browserslist.nodeVersions = jsReleases.map(function(release) {
        return release.version;
      });
    })();
    module2.exports = browserslist;
  }
});

// node_modules/@babel/helper-validator-option/lib/find-suggestion.js
var require_find_suggestion = __commonJS({
  "node_modules/@babel/helper-validator-option/lib/find-suggestion.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.findSuggestion = findSuggestion;
    var {
      min
    } = Math;
    function levenshtein(a, b) {
      let t3 = [], u = [], i, j;
      const m = a.length, n = b.length;
      if (!m) {
        return n;
      }
      if (!n) {
        return m;
      }
      for (j = 0; j <= n; j++) {
        t3[j] = j;
      }
      for (i = 1; i <= m; i++) {
        for (u = [i], j = 1; j <= n; j++) {
          u[j] = a[i - 1] === b[j - 1] ? t3[j - 1] : min(t3[j - 1], t3[j], u[j - 1]) + 1;
        }
        t3 = u;
      }
      return u[n];
    }
    function findSuggestion(str, arr) {
      const distances = arr.map((el) => levenshtein(el, str));
      return arr[distances.indexOf(min(...distances))];
    }
  }
});

// node_modules/@babel/helper-validator-option/lib/validator.js
var require_validator = __commonJS({
  "node_modules/@babel/helper-validator-option/lib/validator.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.OptionValidator = void 0;
    var _findSuggestion = require_find_suggestion();
    var OptionValidator = class {
      constructor(descriptor) {
        this.descriptor = descriptor;
      }
      validateTopLevelOptions(options, TopLevelOptionShape) {
        const validOptionNames = Object.keys(TopLevelOptionShape);
        for (const option of Object.keys(options)) {
          if (!validOptionNames.includes(option)) {
            throw new Error(this.formatMessage(`'${option}' is not a valid top-level option.
- Did you mean '${(0, _findSuggestion.findSuggestion)(option, validOptionNames)}'?`));
          }
        }
      }
      validateBooleanOption(name2, value2, defaultValue) {
        if (value2 === void 0) {
          return defaultValue;
        } else {
          this.invariant(typeof value2 === "boolean", `'${name2}' option must be a boolean.`);
        }
        return value2;
      }
      validateStringOption(name2, value2, defaultValue) {
        if (value2 === void 0) {
          return defaultValue;
        } else {
          this.invariant(typeof value2 === "string", `'${name2}' option must be a string.`);
        }
        return value2;
      }
      invariant(condition, message) {
        if (!condition) {
          throw new Error(this.formatMessage(message));
        }
      }
      formatMessage(message) {
        return `${this.descriptor}: ${message}`;
      }
    };
    exports.OptionValidator = OptionValidator;
  }
});

// node_modules/@babel/helper-validator-option/lib/index.js
var require_lib18 = __commonJS({
  "node_modules/@babel/helper-validator-option/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "OptionValidator", {
      enumerable: true,
      get: function() {
        return _validator.OptionValidator;
      }
    });
    Object.defineProperty(exports, "findSuggestion", {
      enumerable: true,
      get: function() {
        return _findSuggestion.findSuggestion;
      }
    });
    var _validator = require_validator();
    var _findSuggestion = require_find_suggestion();
  }
});

// node_modules/@babel/compat-data/data/native-modules.json
var require_native_modules = __commonJS({
  "node_modules/@babel/compat-data/data/native-modules.json"(exports, module2) {
    module2.exports = {
      "es6.module": {
        chrome: "61",
        and_chr: "61",
        edge: "16",
        firefox: "60",
        and_ff: "60",
        node: "13.2.0",
        opera: "48",
        op_mob: "48",
        safari: "10.1",
        ios: "10.3",
        samsung: "8.2",
        android: "61",
        electron: "2.0",
        ios_saf: "10.3"
      }
    };
  }
});

// node_modules/@babel/compat-data/native-modules.js
var require_native_modules2 = __commonJS({
  "node_modules/@babel/compat-data/native-modules.js"(exports, module2) {
    module2.exports = require_native_modules();
  }
});

// node_modules/@babel/helper-compilation-targets/node_modules/yallist/iterator.js
var require_iterator = __commonJS({
  "node_modules/@babel/helper-compilation-targets/node_modules/yallist/iterator.js"(exports, module2) {
    "use strict";
    module2.exports = function(Yallist) {
      Yallist.prototype[Symbol.iterator] = function* () {
        for (let walker = this.head; walker; walker = walker.next) {
          yield walker.value;
        }
      };
    };
  }
});

// node_modules/@babel/helper-compilation-targets/node_modules/yallist/yallist.js
var require_yallist = __commonJS({
  "node_modules/@babel/helper-compilation-targets/node_modules/yallist/yallist.js"(exports, module2) {
    "use strict";
    module2.exports = Yallist;
    Yallist.Node = Node5;
    Yallist.create = Yallist;
    function Yallist(list3) {
      var self2 = this;
      if (!(self2 instanceof Yallist)) {
        self2 = new Yallist();
      }
      self2.tail = null;
      self2.head = null;
      self2.length = 0;
      if (list3 && typeof list3.forEach === "function") {
        list3.forEach(function(item) {
          self2.push(item);
        });
      } else if (arguments.length > 0) {
        for (var i = 0, l = arguments.length; i < l; i++) {
          self2.push(arguments[i]);
        }
      }
      return self2;
    }
    Yallist.prototype.removeNode = function(node2) {
      if (node2.list !== this) {
        throw new Error("removing node which does not belong to this list");
      }
      var next = node2.next;
      var prev = node2.prev;
      if (next) {
        next.prev = prev;
      }
      if (prev) {
        prev.next = next;
      }
      if (node2 === this.head) {
        this.head = next;
      }
      if (node2 === this.tail) {
        this.tail = prev;
      }
      node2.list.length--;
      node2.next = null;
      node2.prev = null;
      node2.list = null;
      return next;
    };
    Yallist.prototype.unshiftNode = function(node2) {
      if (node2 === this.head) {
        return;
      }
      if (node2.list) {
        node2.list.removeNode(node2);
      }
      var head = this.head;
      node2.list = this;
      node2.next = head;
      if (head) {
        head.prev = node2;
      }
      this.head = node2;
      if (!this.tail) {
        this.tail = node2;
      }
      this.length++;
    };
    Yallist.prototype.pushNode = function(node2) {
      if (node2 === this.tail) {
        return;
      }
      if (node2.list) {
        node2.list.removeNode(node2);
      }
      var tail = this.tail;
      node2.list = this;
      node2.prev = tail;
      if (tail) {
        tail.next = node2;
      }
      this.tail = node2;
      if (!this.head) {
        this.head = node2;
      }
      this.length++;
    };
    Yallist.prototype.push = function() {
      for (var i = 0, l = arguments.length; i < l; i++) {
        push3(this, arguments[i]);
      }
      return this.length;
    };
    Yallist.prototype.unshift = function() {
      for (var i = 0, l = arguments.length; i < l; i++) {
        unshift(this, arguments[i]);
      }
      return this.length;
    };
    Yallist.prototype.pop = function() {
      if (!this.tail) {
        return void 0;
      }
      var res = this.tail.value;
      this.tail = this.tail.prev;
      if (this.tail) {
        this.tail.next = null;
      } else {
        this.head = null;
      }
      this.length--;
      return res;
    };
    Yallist.prototype.shift = function() {
      if (!this.head) {
        return void 0;
      }
      var res = this.head.value;
      this.head = this.head.next;
      if (this.head) {
        this.head.prev = null;
      } else {
        this.tail = null;
      }
      this.length--;
      return res;
    };
    Yallist.prototype.forEach = function(fn, thisp) {
      thisp = thisp || this;
      for (var walker = this.head, i = 0; walker !== null; i++) {
        fn.call(thisp, walker.value, i, this);
        walker = walker.next;
      }
    };
    Yallist.prototype.forEachReverse = function(fn, thisp) {
      thisp = thisp || this;
      for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
        fn.call(thisp, walker.value, i, this);
        walker = walker.prev;
      }
    };
    Yallist.prototype.get = function(n) {
      for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
        walker = walker.next;
      }
      if (i === n && walker !== null) {
        return walker.value;
      }
    };
    Yallist.prototype.getReverse = function(n) {
      for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
        walker = walker.prev;
      }
      if (i === n && walker !== null) {
        return walker.value;
      }
    };
    Yallist.prototype.map = function(fn, thisp) {
      thisp = thisp || this;
      var res = new Yallist();
      for (var walker = this.head; walker !== null; ) {
        res.push(fn.call(thisp, walker.value, this));
        walker = walker.next;
      }
      return res;
    };
    Yallist.prototype.mapReverse = function(fn, thisp) {
      thisp = thisp || this;
      var res = new Yallist();
      for (var walker = this.tail; walker !== null; ) {
        res.push(fn.call(thisp, walker.value, this));
        walker = walker.prev;
      }
      return res;
    };
    Yallist.prototype.reduce = function(fn, initial) {
      var acc;
      var walker = this.head;
      if (arguments.length > 1) {
        acc = initial;
      } else if (this.head) {
        walker = this.head.next;
        acc = this.head.value;
      } else {
        throw new TypeError("Reduce of empty list with no initial value");
      }
      for (var i = 0; walker !== null; i++) {
        acc = fn(acc, walker.value, i);
        walker = walker.next;
      }
      return acc;
    };
    Yallist.prototype.reduceReverse = function(fn, initial) {
      var acc;
      var walker = this.tail;
      if (arguments.length > 1) {
        acc = initial;
      } else if (this.tail) {
        walker = this.tail.prev;
        acc = this.tail.value;
      } else {
        throw new TypeError("Reduce of empty list with no initial value");
      }
      for (var i = this.length - 1; walker !== null; i--) {
        acc = fn(acc, walker.value, i);
        walker = walker.prev;
      }
      return acc;
    };
    Yallist.prototype.toArray = function() {
      var arr = new Array(this.length);
      for (var i = 0, walker = this.head; walker !== null; i++) {
        arr[i] = walker.value;
        walker = walker.next;
      }
      return arr;
    };
    Yallist.prototype.toArrayReverse = function() {
      var arr = new Array(this.length);
      for (var i = 0, walker = this.tail; walker !== null; i++) {
        arr[i] = walker.value;
        walker = walker.prev;
      }
      return arr;
    };
    Yallist.prototype.slice = function(from, to) {
      to = to || this.length;
      if (to < 0) {
        to += this.length;
      }
      from = from || 0;
      if (from < 0) {
        from += this.length;
      }
      var ret = new Yallist();
      if (to < from || to < 0) {
        return ret;
      }
      if (from < 0) {
        from = 0;
      }
      if (to > this.length) {
        to = this.length;
      }
      for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
        walker = walker.next;
      }
      for (; walker !== null && i < to; i++, walker = walker.next) {
        ret.push(walker.value);
      }
      return ret;
    };
    Yallist.prototype.sliceReverse = function(from, to) {
      to = to || this.length;
      if (to < 0) {
        to += this.length;
      }
      from = from || 0;
      if (from < 0) {
        from += this.length;
      }
      var ret = new Yallist();
      if (to < from || to < 0) {
        return ret;
      }
      if (from < 0) {
        from = 0;
      }
      if (to > this.length) {
        to = this.length;
      }
      for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
        walker = walker.prev;
      }
      for (; walker !== null && i > from; i--, walker = walker.prev) {
        ret.push(walker.value);
      }
      return ret;
    };
    Yallist.prototype.splice = function(start3, deleteCount) {
      if (start3 > this.length) {
        start3 = this.length - 1;
      }
      if (start3 < 0) {
        start3 = this.length + start3;
      }
      for (var i = 0, walker = this.head; walker !== null && i < start3; i++) {
        walker = walker.next;
      }
      var ret = [];
      for (var i = 0; walker && i < deleteCount; i++) {
        ret.push(walker.value);
        walker = this.removeNode(walker);
      }
      if (walker === null) {
        walker = this.tail;
      }
      if (walker !== this.head && walker !== this.tail) {
        walker = walker.prev;
      }
      for (var i = 2; i < arguments.length; i++) {
        walker = insert(this, walker, arguments[i]);
      }
      return ret;
    };
    Yallist.prototype.reverse = function() {
      var head = this.head;
      var tail = this.tail;
      for (var walker = head; walker !== null; walker = walker.prev) {
        var p = walker.prev;
        walker.prev = walker.next;
        walker.next = p;
      }
      this.head = tail;
      this.tail = head;
      return this;
    };
    function insert(self2, node2, value2) {
      var inserted = node2 === self2.head ? new Node5(value2, null, node2, self2) : new Node5(value2, node2, node2.next, self2);
      if (inserted.next === null) {
        self2.tail = inserted;
      }
      if (inserted.prev === null) {
        self2.head = inserted;
      }
      self2.length++;
      return inserted;
    }
    function push3(self2, item) {
      self2.tail = new Node5(item, self2.tail, null, self2);
      if (!self2.head) {
        self2.head = self2.tail;
      }
      self2.length++;
    }
    function unshift(self2, item) {
      self2.head = new Node5(item, null, self2.head, self2);
      if (!self2.tail) {
        self2.tail = self2.head;
      }
      self2.length++;
    }
    function Node5(value2, prev, next, list3) {
      if (!(this instanceof Node5)) {
        return new Node5(value2, prev, next, list3);
      }
      this.list = list3;
      this.value = value2;
      if (prev) {
        prev.next = this;
        this.prev = prev;
      } else {
        this.prev = null;
      }
      if (next) {
        next.prev = this;
        this.next = next;
      } else {
        this.next = null;
      }
    }
    try {
      require_iterator()(Yallist);
    } catch (er) {
    }
  }
});

// node_modules/@babel/helper-compilation-targets/node_modules/lru-cache/index.js
var require_lru_cache = __commonJS({
  "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache/index.js"(exports, module2) {
    "use strict";
    var Yallist = require_yallist();
    var MAX = Symbol("max");
    var LENGTH = Symbol("length");
    var LENGTH_CALCULATOR = Symbol("lengthCalculator");
    var ALLOW_STALE = Symbol("allowStale");
    var MAX_AGE = Symbol("maxAge");
    var DISPOSE = Symbol("dispose");
    var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
    var LRU_LIST = Symbol("lruList");
    var CACHE = Symbol("cache");
    var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
    var naiveLength = () => 1;
    var LRUCache = class {
      constructor(options) {
        if (typeof options === "number")
          options = { max: options };
        if (!options)
          options = {};
        if (options.max && (typeof options.max !== "number" || options.max < 0))
          throw new TypeError("max must be a non-negative number");
        const max = this[MAX] = options.max || Infinity;
        const lc = options.length || naiveLength;
        this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
        this[ALLOW_STALE] = options.stale || false;
        if (options.maxAge && typeof options.maxAge !== "number")
          throw new TypeError("maxAge must be a number");
        this[MAX_AGE] = options.maxAge || 0;
        this[DISPOSE] = options.dispose;
        this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
        this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
        this.reset();
      }
      // resize the cache when the max changes.
      set max(mL) {
        if (typeof mL !== "number" || mL < 0)
          throw new TypeError("max must be a non-negative number");
        this[MAX] = mL || Infinity;
        trim(this);
      }
      get max() {
        return this[MAX];
      }
      set allowStale(allowStale) {
        this[ALLOW_STALE] = !!allowStale;
      }
      get allowStale() {
        return this[ALLOW_STALE];
      }
      set maxAge(mA) {
        if (typeof mA !== "number")
          throw new TypeError("maxAge must be a non-negative number");
        this[MAX_AGE] = mA;
        trim(this);
      }
      get maxAge() {
        return this[MAX_AGE];
      }
      // resize the cache when the lengthCalculator changes.
      set lengthCalculator(lC) {
        if (typeof lC !== "function")
          lC = naiveLength;
        if (lC !== this[LENGTH_CALCULATOR]) {
          this[LENGTH_CALCULATOR] = lC;
          this[LENGTH] = 0;
          this[LRU_LIST].forEach((hit) => {
            hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
            this[LENGTH] += hit.length;
          });
        }
        trim(this);
      }
      get lengthCalculator() {
        return this[LENGTH_CALCULATOR];
      }
      get length() {
        return this[LENGTH];
      }
      get itemCount() {
        return this[LRU_LIST].length;
      }
      rforEach(fn, thisp) {
        thisp = thisp || this;
        for (let walker = this[LRU_LIST].tail; walker !== null; ) {
          const prev = walker.prev;
          forEachStep(this, fn, walker, thisp);
          walker = prev;
        }
      }
      forEach(fn, thisp) {
        thisp = thisp || this;
        for (let walker = this[LRU_LIST].head; walker !== null; ) {
          const next = walker.next;
          forEachStep(this, fn, walker, thisp);
          walker = next;
        }
      }
      keys() {
        return this[LRU_LIST].toArray().map((k) => k.key);
      }
      values() {
        return this[LRU_LIST].toArray().map((k) => k.value);
      }
      reset() {
        if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
          this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
        }
        this[CACHE] = /* @__PURE__ */ new Map();
        this[LRU_LIST] = new Yallist();
        this[LENGTH] = 0;
      }
      dump() {
        return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
          k: hit.key,
          v: hit.value,
          e: hit.now + (hit.maxAge || 0)
        }).toArray().filter((h) => h);
      }
      dumpLru() {
        return this[LRU_LIST];
      }
      set(key2, value2, maxAge) {
        maxAge = maxAge || this[MAX_AGE];
        if (maxAge && typeof maxAge !== "number")
          throw new TypeError("maxAge must be a number");
        const now = maxAge ? Date.now() : 0;
        const len = this[LENGTH_CALCULATOR](value2, key2);
        if (this[CACHE].has(key2)) {
          if (len > this[MAX]) {
            del(this, this[CACHE].get(key2));
            return false;
          }
          const node2 = this[CACHE].get(key2);
          const item = node2.value;
          if (this[DISPOSE]) {
            if (!this[NO_DISPOSE_ON_SET])
              this[DISPOSE](key2, item.value);
          }
          item.now = now;
          item.maxAge = maxAge;
          item.value = value2;
          this[LENGTH] += len - item.length;
          item.length = len;
          this.get(key2);
          trim(this);
          return true;
        }
        const hit = new Entry(key2, value2, len, now, maxAge);
        if (hit.length > this[MAX]) {
          if (this[DISPOSE])
            this[DISPOSE](key2, value2);
          return false;
        }
        this[LENGTH] += hit.length;
        this[LRU_LIST].unshift(hit);
        this[CACHE].set(key2, this[LRU_LIST].head);
        trim(this);
        return true;
      }
      has(key2) {
        if (!this[CACHE].has(key2))
          return false;
        const hit = this[CACHE].get(key2).value;
        return !isStale(this, hit);
      }
      get(key2) {
        return get(this, key2, true);
      }
      peek(key2) {
        return get(this, key2, false);
      }
      pop() {
        const node2 = this[LRU_LIST].tail;
        if (!node2)
          return null;
        del(this, node2);
        return node2.value;
      }
      del(key2) {
        del(this, this[CACHE].get(key2));
      }
      load(arr) {
        this.reset();
        const now = Date.now();
        for (let l = arr.length - 1; l >= 0; l--) {
          const hit = arr[l];
          const expiresAt = hit.e || 0;
          if (expiresAt === 0)
            this.set(hit.k, hit.v);
          else {
            const maxAge = expiresAt - now;
            if (maxAge > 0) {
              this.set(hit.k, hit.v, maxAge);
            }
          }
        }
      }
      prune() {
        this[CACHE].forEach((value2, key2) => get(this, key2, false));
      }
    };
    var get = (self2, key2, doUse) => {
      const node2 = self2[CACHE].get(key2);
      if (node2) {
        const hit = node2.value;
        if (isStale(self2, hit)) {
          del(self2, node2);
          if (!self2[ALLOW_STALE])
            return void 0;
        } else {
          if (doUse) {
            if (self2[UPDATE_AGE_ON_GET])
              node2.value.now = Date.now();
            self2[LRU_LIST].unshiftNode(node2);
          }
        }
        return hit.value;
      }
    };
    var isStale = (self2, hit) => {
      if (!hit || !hit.maxAge && !self2[MAX_AGE])
        return false;
      const diff = Date.now() - hit.now;
      return hit.maxAge ? diff > hit.maxAge : self2[MAX_AGE] && diff > self2[MAX_AGE];
    };
    var trim = (self2) => {
      if (self2[LENGTH] > self2[MAX]) {
        for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
          const prev = walker.prev;
          del(self2, walker);
          walker = prev;
        }
      }
    };
    var del = (self2, node2) => {
      if (node2) {
        const hit = node2.value;
        if (self2[DISPOSE])
          self2[DISPOSE](hit.key, hit.value);
        self2[LENGTH] -= hit.length;
        self2[CACHE].delete(hit.key);
        self2[LRU_LIST].removeNode(node2);
      }
    };
    var Entry = class {
      constructor(key2, value2, length, now, maxAge) {
        this.key = key2;
        this.value = value2;
        this.length = length;
        this.now = now;
        this.maxAge = maxAge || 0;
      }
    };
    var forEachStep = (self2, fn, node2, thisp) => {
      let hit = node2.value;
      if (isStale(self2, hit)) {
        del(self2, node2);
        if (!self2[ALLOW_STALE])
          hit = void 0;
      }
      if (hit)
        fn.call(thisp, hit.value, hit.key, self2);
    };
    module2.exports = LRUCache;
  }
});

// node_modules/@babel/helper-compilation-targets/node_modules/semver/semver.js
var require_semver2 = __commonJS({
  "node_modules/@babel/helper-compilation-targets/node_modules/semver/semver.js"(exports, module2) {
    exports = module2.exports = SemVer;
    var debug;
    if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
      debug = function() {
        var args = Array.prototype.slice.call(arguments, 0);
        args.unshift("SEMVER");
        console.log.apply(console, args);
      };
    } else {
      debug = function() {
      };
    }
    exports.SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
    9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var re = exports.re = [];
    var src = exports.src = [];
    var t3 = exports.tokens = {};
    var R = 0;
    function tok(n) {
      t3[n] = R++;
    }
    tok("NUMERICIDENTIFIER");
    src[t3.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
    tok("NUMERICIDENTIFIERLOOSE");
    src[t3.NUMERICIDENTIFIERLOOSE] = "[0-9]+";
    tok("NONNUMERICIDENTIFIER");
    src[t3.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
    tok("MAINVERSION");
    src[t3.MAINVERSION] = "(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")";
    tok("MAINVERSIONLOOSE");
    src[t3.MAINVERSIONLOOSE] = "(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")";
    tok("PRERELEASEIDENTIFIER");
    src[t3.PRERELEASEIDENTIFIER] = "(?:" + src[t3.NUMERICIDENTIFIER] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
    tok("PRERELEASEIDENTIFIERLOOSE");
    src[t3.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t3.NUMERICIDENTIFIERLOOSE] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
    tok("PRERELEASE");
    src[t3.PRERELEASE] = "(?:-(" + src[t3.PRERELEASEIDENTIFIER] + "(?:\\." + src[t3.PRERELEASEIDENTIFIER] + ")*))";
    tok("PRERELEASELOOSE");
    src[t3.PRERELEASELOOSE] = "(?:-?(" + src[t3.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t3.PRERELEASEIDENTIFIERLOOSE] + ")*))";
    tok("BUILDIDENTIFIER");
    src[t3.BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
    tok("BUILD");
    src[t3.BUILD] = "(?:\\+(" + src[t3.BUILDIDENTIFIER] + "(?:\\." + src[t3.BUILDIDENTIFIER] + ")*))";
    tok("FULL");
    tok("FULLPLAIN");
    src[t3.FULLPLAIN] = "v?" + src[t3.MAINVERSION] + src[t3.PRERELEASE] + "?" + src[t3.BUILD] + "?";
    src[t3.FULL] = "^" + src[t3.FULLPLAIN] + "$";
    tok("LOOSEPLAIN");
    src[t3.LOOSEPLAIN] = "[v=\\s]*" + src[t3.MAINVERSIONLOOSE] + src[t3.PRERELEASELOOSE] + "?" + src[t3.BUILD] + "?";
    tok("LOOSE");
    src[t3.LOOSE] = "^" + src[t3.LOOSEPLAIN] + "$";
    tok("GTLT");
    src[t3.GTLT] = "((?:<|>)?=?)";
    tok("XRANGEIDENTIFIERLOOSE");
    src[t3.XRANGEIDENTIFIERLOOSE] = src[t3.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
    tok("XRANGEIDENTIFIER");
    src[t3.XRANGEIDENTIFIER] = src[t3.NUMERICIDENTIFIER] + "|x|X|\\*";
    tok("XRANGEPLAIN");
    src[t3.XRANGEPLAIN] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:" + src[t3.PRERELEASE] + ")?" + src[t3.BUILD] + "?)?)?";
    tok("XRANGEPLAINLOOSE");
    src[t3.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t3.PRERELEASELOOSE] + ")?" + src[t3.BUILD] + "?)?)?";
    tok("XRANGE");
    src[t3.XRANGE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAIN] + "$";
    tok("XRANGELOOSE");
    src[t3.XRANGELOOSE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAINLOOSE] + "$";
    tok("COERCE");
    src[t3.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
    tok("COERCERTL");
    re[t3.COERCERTL] = new RegExp(src[t3.COERCE], "g");
    tok("LONETILDE");
    src[t3.LONETILDE] = "(?:~>?)";
    tok("TILDETRIM");
    src[t3.TILDETRIM] = "(\\s*)" + src[t3.LONETILDE] + "\\s+";
    re[t3.TILDETRIM] = new RegExp(src[t3.TILDETRIM], "g");
    var tildeTrimReplace = "$1~";
    tok("TILDE");
    src[t3.TILDE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAIN] + "$";
    tok("TILDELOOSE");
    src[t3.TILDELOOSE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAINLOOSE] + "$";
    tok("LONECARET");
    src[t3.LONECARET] = "(?:\\^)";
    tok("CARETTRIM");
    src[t3.CARETTRIM] = "(\\s*)" + src[t3.LONECARET] + "\\s+";
    re[t3.CARETTRIM] = new RegExp(src[t3.CARETTRIM], "g");
    var caretTrimReplace = "$1^";
    tok("CARET");
    src[t3.CARET] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAIN] + "$";
    tok("CARETLOOSE");
    src[t3.CARETLOOSE] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAINLOOSE] + "$";
    tok("COMPARATORLOOSE");
    src[t3.COMPARATORLOOSE] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + ")$|^$";
    tok("COMPARATOR");
    src[t3.COMPARATOR] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.FULLPLAIN] + ")$|^$";
    tok("COMPARATORTRIM");
    src[t3.COMPARATORTRIM] = "(\\s*)" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + "|" + src[t3.XRANGEPLAIN] + ")";
    re[t3.COMPARATORTRIM] = new RegExp(src[t3.COMPARATORTRIM], "g");
    var comparatorTrimReplace = "$1$2$3";
    tok("HYPHENRANGE");
    src[t3.HYPHENRANGE] = "^\\s*(" + src[t3.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t3.XRANGEPLAIN] + ")\\s*$";
    tok("HYPHENRANGELOOSE");
    src[t3.HYPHENRANGELOOSE] = "^\\s*(" + src[t3.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t3.XRANGEPLAINLOOSE] + ")\\s*$";
    tok("STAR");
    src[t3.STAR] = "(<|>)?=?\\s*\\*";
    for (i = 0; i < R; i++) {
      debug(i, src[i]);
      if (!re[i]) {
        re[i] = new RegExp(src[i]);
      }
    }
    var i;
    exports.parse = parse9;
    function parse9(version3, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 !== "string") {
        return null;
      }
      if (version3.length > MAX_LENGTH) {
        return null;
      }
      var r = options.loose ? re[t3.LOOSE] : re[t3.FULL];
      if (!r.test(version3)) {
        return null;
      }
      try {
        return new SemVer(version3, options);
      } catch (er) {
        return null;
      }
    }
    exports.valid = valid2;
    function valid2(version3, options) {
      var v = parse9(version3, options);
      return v ? v.version : null;
    }
    exports.clean = clean2;
    function clean2(version3, options) {
      var s = parse9(version3.trim().replace(/^[=v]+/, ""), options);
      return s ? s.version : null;
    }
    exports.SemVer = SemVer;
    function SemVer(version3, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (version3 instanceof SemVer) {
        if (version3.loose === options.loose) {
          return version3;
        } else {
          version3 = version3.version;
        }
      } else if (typeof version3 !== "string") {
        throw new TypeError("Invalid Version: " + version3);
      }
      if (version3.length > MAX_LENGTH) {
        throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
      }
      if (!(this instanceof SemVer)) {
        return new SemVer(version3, options);
      }
      debug("SemVer", version3, options);
      this.options = options;
      this.loose = !!options.loose;
      var m = version3.trim().match(options.loose ? re[t3.LOOSE] : re[t3.FULL]);
      if (!m) {
        throw new TypeError("Invalid Version: " + version3);
      }
      this.raw = version3;
      this.major = +m[1];
      this.minor = +m[2];
      this.patch = +m[3];
      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
        throw new TypeError("Invalid major version");
      }
      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
        throw new TypeError("Invalid minor version");
      }
      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
        throw new TypeError("Invalid patch version");
      }
      if (!m[4]) {
        this.prerelease = [];
      } else {
        this.prerelease = m[4].split(".").map(function(id) {
          if (/^[0-9]+$/.test(id)) {
            var num = +id;
            if (num >= 0 && num < MAX_SAFE_INTEGER) {
              return num;
            }
          }
          return id;
        });
      }
      this.build = m[5] ? m[5].split(".") : [];
      this.format();
    }
    SemVer.prototype.format = function() {
      this.version = this.major + "." + this.minor + "." + this.patch;
      if (this.prerelease.length) {
        this.version += "-" + this.prerelease.join(".");
      }
      return this.version;
    };
    SemVer.prototype.toString = function() {
      return this.version;
    };
    SemVer.prototype.compare = function(other) {
      debug("SemVer.compare", this.version, this.options, other);
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      return this.compareMain(other) || this.comparePre(other);
    };
    SemVer.prototype.compareMain = function(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
    };
    SemVer.prototype.comparePre = function(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      if (this.prerelease.length && !other.prerelease.length) {
        return -1;
      } else if (!this.prerelease.length && other.prerelease.length) {
        return 1;
      } else if (!this.prerelease.length && !other.prerelease.length) {
        return 0;
      }
      var i2 = 0;
      do {
        var a = this.prerelease[i2];
        var b = other.prerelease[i2];
        debug("prerelease compare", i2, a, b);
        if (a === void 0 && b === void 0) {
          return 0;
        } else if (b === void 0) {
          return 1;
        } else if (a === void 0) {
          return -1;
        } else if (a === b) {
          continue;
        } else {
          return compareIdentifiers(a, b);
        }
      } while (++i2);
    };
    SemVer.prototype.compareBuild = function(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      var i2 = 0;
      do {
        var a = this.build[i2];
        var b = other.build[i2];
        debug("prerelease compare", i2, a, b);
        if (a === void 0 && b === void 0) {
          return 0;
        } else if (b === void 0) {
          return 1;
        } else if (a === void 0) {
          return -1;
        } else if (a === b) {
          continue;
        } else {
          return compareIdentifiers(a, b);
        }
      } while (++i2);
    };
    SemVer.prototype.inc = function(release, identifier) {
      switch (release) {
        case "premajor":
          this.prerelease.length = 0;
          this.patch = 0;
          this.minor = 0;
          this.major++;
          this.inc("pre", identifier);
          break;
        case "preminor":
          this.prerelease.length = 0;
          this.patch = 0;
          this.minor++;
          this.inc("pre", identifier);
          break;
        case "prepatch":
          this.prerelease.length = 0;
          this.inc("patch", identifier);
          this.inc("pre", identifier);
          break;
        case "prerelease":
          if (this.prerelease.length === 0) {
            this.inc("patch", identifier);
          }
          this.inc("pre", identifier);
          break;
        case "major":
          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
            this.major++;
          }
          this.minor = 0;
          this.patch = 0;
          this.prerelease = [];
          break;
        case "minor":
          if (this.patch !== 0 || this.prerelease.length === 0) {
            this.minor++;
          }
          this.patch = 0;
          this.prerelease = [];
          break;
        case "patch":
          if (this.prerelease.length === 0) {
            this.patch++;
          }
          this.prerelease = [];
          break;
        case "pre":
          if (this.prerelease.length === 0) {
            this.prerelease = [0];
          } else {
            var i2 = this.prerelease.length;
            while (--i2 >= 0) {
              if (typeof this.prerelease[i2] === "number") {
                this.prerelease[i2]++;
                i2 = -2;
              }
            }
            if (i2 === -1) {
              this.prerelease.push(0);
            }
          }
          if (identifier) {
            if (this.prerelease[0] === identifier) {
              if (isNaN(this.prerelease[1])) {
                this.prerelease = [identifier, 0];
              }
            } else {
              this.prerelease = [identifier, 0];
            }
          }
          break;
        default:
          throw new Error("invalid increment argument: " + release);
      }
      this.format();
      this.raw = this.version;
      return this;
    };
    exports.inc = inc;
    function inc(version3, release, loose, identifier) {
      if (typeof loose === "string") {
        identifier = loose;
        loose = void 0;
      }
      try {
        return new SemVer(version3, loose).inc(release, identifier).version;
      } catch (er) {
        return null;
      }
    }
    exports.diff = diff;
    function diff(version1, version22) {
      if (eq(version1, version22)) {
        return null;
      } else {
        var v1 = parse9(version1);
        var v2 = parse9(version22);
        var prefix = "";
        if (v1.prerelease.length || v2.prerelease.length) {
          prefix = "pre";
          var defaultResult = "prerelease";
        }
        for (var key2 in v1) {
          if (key2 === "major" || key2 === "minor" || key2 === "patch") {
            if (v1[key2] !== v2[key2]) {
              return prefix + key2;
            }
          }
        }
        return defaultResult;
      }
    }
    exports.compareIdentifiers = compareIdentifiers;
    var numeric = /^[0-9]+$/;
    function compareIdentifiers(a, b) {
      var anum = numeric.test(a);
      var bnum = numeric.test(b);
      if (anum && bnum) {
        a = +a;
        b = +b;
      }
      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
    }
    exports.rcompareIdentifiers = rcompareIdentifiers;
    function rcompareIdentifiers(a, b) {
      return compareIdentifiers(b, a);
    }
    exports.major = major;
    function major(a, loose) {
      return new SemVer(a, loose).major;
    }
    exports.minor = minor;
    function minor(a, loose) {
      return new SemVer(a, loose).minor;
    }
    exports.patch = patch3;
    function patch3(a, loose) {
      return new SemVer(a, loose).patch;
    }
    exports.compare = compare2;
    function compare2(a, b, loose) {
      return new SemVer(a, loose).compare(new SemVer(b, loose));
    }
    exports.compareLoose = compareLoose;
    function compareLoose(a, b) {
      return compare2(a, b, true);
    }
    exports.compareBuild = compareBuild;
    function compareBuild(a, b, loose) {
      var versionA = new SemVer(a, loose);
      var versionB = new SemVer(b, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    }
    exports.rcompare = rcompare;
    function rcompare(a, b, loose) {
      return compare2(b, a, loose);
    }
    exports.sort = sort;
    function sort(list3, loose) {
      return list3.sort(function(a, b) {
        return exports.compareBuild(a, b, loose);
      });
    }
    exports.rsort = rsort;
    function rsort(list3, loose) {
      return list3.sort(function(a, b) {
        return exports.compareBuild(b, a, loose);
      });
    }
    exports.gt = gt;
    function gt(a, b, loose) {
      return compare2(a, b, loose) > 0;
    }
    exports.lt = lt;
    function lt(a, b, loose) {
      return compare2(a, b, loose) < 0;
    }
    exports.eq = eq;
    function eq(a, b, loose) {
      return compare2(a, b, loose) === 0;
    }
    exports.neq = neq;
    function neq(a, b, loose) {
      return compare2(a, b, loose) !== 0;
    }
    exports.gte = gte;
    function gte(a, b, loose) {
      return compare2(a, b, loose) >= 0;
    }
    exports.lte = lte;
    function lte(a, b, loose) {
      return compare2(a, b, loose) <= 0;
    }
    exports.cmp = cmp;
    function cmp(a, op, b, loose) {
      switch (op) {
        case "===":
          if (typeof a === "object")
            a = a.version;
          if (typeof b === "object")
            b = b.version;
          return a === b;
        case "!==":
          if (typeof a === "object")
            a = a.version;
          if (typeof b === "object")
            b = b.version;
          return a !== b;
        case "":
        case "=":
        case "==":
          return eq(a, b, loose);
        case "!=":
          return neq(a, b, loose);
        case ">":
          return gt(a, b, loose);
        case ">=":
          return gte(a, b, loose);
        case "<":
          return lt(a, b, loose);
        case "<=":
          return lte(a, b, loose);
        default:
          throw new TypeError("Invalid operator: " + op);
      }
    }
    exports.Comparator = Comparator;
    function Comparator(comp, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (comp instanceof Comparator) {
        if (comp.loose === !!options.loose) {
          return comp;
        } else {
          comp = comp.value;
        }
      }
      if (!(this instanceof Comparator)) {
        return new Comparator(comp, options);
      }
      debug("comparator", comp, options);
      this.options = options;
      this.loose = !!options.loose;
      this.parse(comp);
      if (this.semver === ANY) {
        this.value = "";
      } else {
        this.value = this.operator + this.semver.version;
      }
      debug("comp", this);
    }
    var ANY = {};
    Comparator.prototype.parse = function(comp) {
      var r = this.options.loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
      var m = comp.match(r);
      if (!m) {
        throw new TypeError("Invalid comparator: " + comp);
      }
      this.operator = m[1] !== void 0 ? m[1] : "";
      if (this.operator === "=") {
        this.operator = "";
      }
      if (!m[2]) {
        this.semver = ANY;
      } else {
        this.semver = new SemVer(m[2], this.options.loose);
      }
    };
    Comparator.prototype.toString = function() {
      return this.value;
    };
    Comparator.prototype.test = function(version3) {
      debug("Comparator.test", version3, this.options.loose);
      if (this.semver === ANY || version3 === ANY) {
        return true;
      }
      if (typeof version3 === "string") {
        try {
          version3 = new SemVer(version3, this.options);
        } catch (er) {
          return false;
        }
      }
      return cmp(version3, this.operator, this.semver, this.options);
    };
    Comparator.prototype.intersects = function(comp, options) {
      if (!(comp instanceof Comparator)) {
        throw new TypeError("a Comparator is required");
      }
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      var rangeTmp;
      if (this.operator === "") {
        if (this.value === "") {
          return true;
        }
        rangeTmp = new Range(comp.value, options);
        return satisfies(this.value, rangeTmp, options);
      } else if (comp.operator === "") {
        if (comp.value === "") {
          return true;
        }
        rangeTmp = new Range(this.value, options);
        return satisfies(comp.semver, rangeTmp, options);
      }
      var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
      var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
      var sameSemVer = this.semver.version === comp.semver.version;
      var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
      var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && ((this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<"));
      var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && ((this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">"));
      return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
    };
    exports.Range = Range;
    function Range(range, options) {
      if (!options || typeof options !== "object") {
        options = {
          loose: !!options,
          includePrerelease: false
        };
      }
      if (range instanceof Range) {
        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
          return range;
        } else {
          return new Range(range.raw, options);
        }
      }
      if (range instanceof Comparator) {
        return new Range(range.value, options);
      }
      if (!(this instanceof Range)) {
        return new Range(range, options);
      }
      this.options = options;
      this.loose = !!options.loose;
      this.includePrerelease = !!options.includePrerelease;
      this.raw = range;
      this.set = range.split(/\s*\|\|\s*/).map(function(range2) {
        return this.parseRange(range2.trim());
      }, this).filter(function(c2) {
        return c2.length;
      });
      if (!this.set.length) {
        throw new TypeError("Invalid SemVer Range: " + range);
      }
      this.format();
    }
    Range.prototype.format = function() {
      this.range = this.set.map(function(comps) {
        return comps.join(" ").trim();
      }).join("||").trim();
      return this.range;
    };
    Range.prototype.toString = function() {
      return this.range;
    };
    Range.prototype.parseRange = function(range) {
      var loose = this.options.loose;
      range = range.trim();
      var hr = loose ? re[t3.HYPHENRANGELOOSE] : re[t3.HYPHENRANGE];
      range = range.replace(hr, hyphenReplace);
      debug("hyphen replace", range);
      range = range.replace(re[t3.COMPARATORTRIM], comparatorTrimReplace);
      debug("comparator trim", range, re[t3.COMPARATORTRIM]);
      range = range.replace(re[t3.TILDETRIM], tildeTrimReplace);
      range = range.replace(re[t3.CARETTRIM], caretTrimReplace);
      range = range.split(/\s+/).join(" ");
      var compRe = loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
      var set = range.split(" ").map(function(comp) {
        return parseComparator(comp, this.options);
      }, this).join(" ").split(/\s+/);
      if (this.options.loose) {
        set = set.filter(function(comp) {
          return !!comp.match(compRe);
        });
      }
      set = set.map(function(comp) {
        return new Comparator(comp, this.options);
      }, this);
      return set;
    };
    Range.prototype.intersects = function(range, options) {
      if (!(range instanceof Range)) {
        throw new TypeError("a Range is required");
      }
      return this.set.some(function(thisComparators) {
        return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {
          return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {
            return rangeComparators.every(function(rangeComparator) {
              return thisComparator.intersects(rangeComparator, options);
            });
          });
        });
      });
    };
    function isSatisfiable(comparators, options) {
      var result = true;
      var remainingComparators = comparators.slice();
      var testComparator = remainingComparators.pop();
      while (result && remainingComparators.length) {
        result = remainingComparators.every(function(otherComparator) {
          return testComparator.intersects(otherComparator, options);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    }
    exports.toComparators = toComparators;
    function toComparators(range, options) {
      return new Range(range, options).set.map(function(comp) {
        return comp.map(function(c2) {
          return c2.value;
        }).join(" ").trim().split(" ");
      });
    }
    function parseComparator(comp, options) {
      debug("comp", comp, options);
      comp = replaceCarets(comp, options);
      debug("caret", comp);
      comp = replaceTildes(comp, options);
      debug("tildes", comp);
      comp = replaceXRanges(comp, options);
      debug("xrange", comp);
      comp = replaceStars(comp, options);
      debug("stars", comp);
      return comp;
    }
    function isX(id) {
      return !id || id.toLowerCase() === "x" || id === "*";
    }
    function replaceTildes(comp, options) {
      return comp.trim().split(/\s+/).map(function(comp2) {
        return replaceTilde(comp2, options);
      }).join(" ");
    }
    function replaceTilde(comp, options) {
      var r = options.loose ? re[t3.TILDELOOSE] : re[t3.TILDE];
      return comp.replace(r, function(_, M, m, p, pr) {
        debug("tilde", comp, _, M, m, p, pr);
        var ret;
        if (isX(M)) {
          ret = "";
        } else if (isX(m)) {
          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
        } else if (isX(p)) {
          ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
        } else if (pr) {
          debug("replaceTilde pr", pr);
          ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
        } else {
          ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
        }
        debug("tilde return", ret);
        return ret;
      });
    }
    function replaceCarets(comp, options) {
      return comp.trim().split(/\s+/).map(function(comp2) {
        return replaceCaret(comp2, options);
      }).join(" ");
    }
    function replaceCaret(comp, options) {
      debug("caret", comp, options);
      var r = options.loose ? re[t3.CARETLOOSE] : re[t3.CARET];
      return comp.replace(r, function(_, M, m, p, pr) {
        debug("caret", comp, _, M, m, p, pr);
        var ret;
        if (isX(M)) {
          ret = "";
        } else if (isX(m)) {
          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
        } else if (isX(p)) {
          if (M === "0") {
            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
          } else {
            ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
          }
        } else if (pr) {
          debug("replaceCaret pr", pr);
          if (M === "0") {
            if (m === "0") {
              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
            } else {
              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
            }
          } else {
            ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
          }
        } else {
          debug("no pr");
          if (M === "0") {
            if (m === "0") {
              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
            } else {
              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
            }
          } else {
            ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
          }
        }
        debug("caret return", ret);
        return ret;
      });
    }
    function replaceXRanges(comp, options) {
      debug("replaceXRanges", comp, options);
      return comp.split(/\s+/).map(function(comp2) {
        return replaceXRange(comp2, options);
      }).join(" ");
    }
    function replaceXRange(comp, options) {
      comp = comp.trim();
      var r = options.loose ? re[t3.XRANGELOOSE] : re[t3.XRANGE];
      return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
        debug("xRange", comp, ret, gtlt, M, m, p, pr);
        var xM = isX(M);
        var xm = xM || isX(m);
        var xp = xm || isX(p);
        var anyX = xp;
        if (gtlt === "=" && anyX) {
          gtlt = "";
        }
        pr = options.includePrerelease ? "-0" : "";
        if (xM) {
          if (gtlt === ">" || gtlt === "<") {
            ret = "<0.0.0-0";
          } else {
            ret = "*";
          }
        } else if (gtlt && anyX) {
          if (xm) {
            m = 0;
          }
          p = 0;
          if (gtlt === ">") {
            gtlt = ">=";
            if (xm) {
              M = +M + 1;
              m = 0;
              p = 0;
            } else {
              m = +m + 1;
              p = 0;
            }
          } else if (gtlt === "<=") {
            gtlt = "<";
            if (xm) {
              M = +M + 1;
            } else {
              m = +m + 1;
            }
          }
          ret = gtlt + M + "." + m + "." + p + pr;
        } else if (xm) {
          ret = ">=" + M + ".0.0" + pr + " <" + (+M + 1) + ".0.0" + pr;
        } else if (xp) {
          ret = ">=" + M + "." + m + ".0" + pr + " <" + M + "." + (+m + 1) + ".0" + pr;
        }
        debug("xRange return", ret);
        return ret;
      });
    }
    function replaceStars(comp, options) {
      debug("replaceStars", comp, options);
      return comp.trim().replace(re[t3.STAR], "");
    }
    function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
      if (isX(fM)) {
        from = "";
      } else if (isX(fm)) {
        from = ">=" + fM + ".0.0";
      } else if (isX(fp)) {
        from = ">=" + fM + "." + fm + ".0";
      } else {
        from = ">=" + from;
      }
      if (isX(tM)) {
        to = "";
      } else if (isX(tm)) {
        to = "<" + (+tM + 1) + ".0.0";
      } else if (isX(tp)) {
        to = "<" + tM + "." + (+tm + 1) + ".0";
      } else if (tpr) {
        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
      } else {
        to = "<=" + to;
      }
      return (from + " " + to).trim();
    }
    Range.prototype.test = function(version3) {
      if (!version3) {
        return false;
      }
      if (typeof version3 === "string") {
        try {
          version3 = new SemVer(version3, this.options);
        } catch (er) {
          return false;
        }
      }
      for (var i2 = 0; i2 < this.set.length; i2++) {
        if (testSet(this.set[i2], version3, this.options)) {
          return true;
        }
      }
      return false;
    };
    function testSet(set, version3, options) {
      for (var i2 = 0; i2 < set.length; i2++) {
        if (!set[i2].test(version3)) {
          return false;
        }
      }
      if (version3.prerelease.length && !options.includePrerelease) {
        for (i2 = 0; i2 < set.length; i2++) {
          debug(set[i2].semver);
          if (set[i2].semver === ANY) {
            continue;
          }
          if (set[i2].semver.prerelease.length > 0) {
            var allowed = set[i2].semver;
            if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    }
    exports.satisfies = satisfies;
    function satisfies(version3, range, options) {
      try {
        range = new Range(range, options);
      } catch (er) {
        return false;
      }
      return range.test(version3);
    }
    exports.maxSatisfying = maxSatisfying;
    function maxSatisfying(versions, range, options) {
      var max = null;
      var maxSV = null;
      try {
        var rangeObj = new Range(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach(function(v) {
        if (rangeObj.test(v)) {
          if (!max || maxSV.compare(v) === -1) {
            max = v;
            maxSV = new SemVer(max, options);
          }
        }
      });
      return max;
    }
    exports.minSatisfying = minSatisfying;
    function minSatisfying(versions, range, options) {
      var min = null;
      var minSV = null;
      try {
        var rangeObj = new Range(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach(function(v) {
        if (rangeObj.test(v)) {
          if (!min || minSV.compare(v) === 1) {
            min = v;
            minSV = new SemVer(min, options);
          }
        }
      });
      return min;
    }
    exports.minVersion = minVersion;
    function minVersion(range, loose) {
      range = new Range(range, loose);
      var minver = new SemVer("0.0.0");
      if (range.test(minver)) {
        return minver;
      }
      minver = new SemVer("0.0.0-0");
      if (range.test(minver)) {
        return minver;
      }
      minver = null;
      for (var i2 = 0; i2 < range.set.length; ++i2) {
        var comparators = range.set[i2];
        comparators.forEach(function(comparator) {
          var compver = new SemVer(comparator.semver.version);
          switch (comparator.operator) {
            case ">":
              if (compver.prerelease.length === 0) {
                compver.patch++;
              } else {
                compver.prerelease.push(0);
              }
              compver.raw = compver.format();
            case "":
            case ">=":
              if (!minver || gt(minver, compver)) {
                minver = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            default:
              throw new Error("Unexpected operation: " + comparator.operator);
          }
        });
      }
      if (minver && range.test(minver)) {
        return minver;
      }
      return null;
    }
    exports.validRange = validRange;
    function validRange(range, options) {
      try {
        return new Range(range, options).range || "*";
      } catch (er) {
        return null;
      }
    }
    exports.ltr = ltr;
    function ltr(version3, range, options) {
      return outside(version3, range, "<", options);
    }
    exports.gtr = gtr;
    function gtr(version3, range, options) {
      return outside(version3, range, ">", options);
    }
    exports.outside = outside;
    function outside(version3, range, hilo, options) {
      version3 = new SemVer(version3, options);
      range = new Range(range, options);
      var gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt;
          ltefn = lte;
          ltfn = lt;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt;
          ltefn = gte;
          ltfn = gt;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies(version3, range, options)) {
        return false;
      }
      for (var i2 = 0; i2 < range.set.length; ++i2) {
        var comparators = range.set[i2];
        var high = null;
        var low = null;
        comparators.forEach(function(comparator) {
          if (comparator.semver === ANY) {
            comparator = new Comparator(">=0.0.0");
          }
          high = high || comparator;
          low = low || comparator;
          if (gtfn(comparator.semver, high.semver, options)) {
            high = comparator;
          } else if (ltfn(comparator.semver, low.semver, options)) {
            low = comparator;
          }
        });
        if (high.operator === comp || high.operator === ecomp) {
          return false;
        }
        if ((!low.operator || low.operator === comp) && ltefn(version3, low.semver)) {
          return false;
        } else if (low.operator === ecomp && ltfn(version3, low.semver)) {
          return false;
        }
      }
      return true;
    }
    exports.prerelease = prerelease;
    function prerelease(version3, options) {
      var parsed = parse9(version3, options);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    }
    exports.intersects = intersects;
    function intersects(r1, r2, options) {
      r1 = new Range(r1, options);
      r2 = new Range(r2, options);
      return r1.intersects(r2);
    }
    exports.coerce = coerce;
    function coerce(version3, options) {
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 === "number") {
        version3 = String(version3);
      }
      if (typeof version3 !== "string") {
        return null;
      }
      options = options || {};
      var match = null;
      if (!options.rtl) {
        match = version3.match(re[t3.COERCE]);
      } else {
        var next;
        while ((next = re[t3.COERCERTL].exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
          if (!match || next.index + next[0].length !== match.index + match[0].length) {
            match = next;
          }
          re[t3.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
        }
        re[t3.COERCERTL].lastIndex = -1;
      }
      if (match === null) {
        return null;
      }
      return parse9(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options);
    }
  }
});

// node_modules/@babel/helper-compilation-targets/lib/targets.js
var require_targets = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/targets.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unreleasedLabels = exports.browserNameMap = void 0;
    var unreleasedLabels = {
      safari: "tp"
    };
    exports.unreleasedLabels = unreleasedLabels;
    var browserNameMap = {
      and_chr: "chrome",
      and_ff: "firefox",
      android: "android",
      chrome: "chrome",
      edge: "edge",
      firefox: "firefox",
      ie: "ie",
      ie_mob: "ie",
      ios_saf: "ios",
      node: "node",
      deno: "deno",
      op_mob: "opera",
      opera: "opera",
      safari: "safari",
      samsung: "samsung"
    };
    exports.browserNameMap = browserNameMap;
  }
});

// node_modules/@babel/helper-compilation-targets/lib/utils.js
var require_utils3 = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.getHighestUnreleased = getHighestUnreleased;
    exports.getLowestImplementedVersion = getLowestImplementedVersion;
    exports.getLowestUnreleased = getLowestUnreleased;
    exports.isUnreleasedVersion = isUnreleasedVersion;
    exports.semverMin = semverMin;
    exports.semverify = semverify;
    var _semver = require_semver2();
    var _helperValidatorOption = require_lib18();
    var _targets = require_targets();
    var versionRegExp = /^(\d+|\d+.\d+)$/;
    var v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
    function semverMin(first, second) {
      return first && _semver.lt(first, second) ? first : second;
    }
    function semverify(version3) {
      if (typeof version3 === "string" && _semver.valid(version3)) {
        return version3;
      }
      v.invariant(typeof version3 === "number" || typeof version3 === "string" && versionRegExp.test(version3), `'${version3}' is not a valid version`);
      version3 = version3.toString();
      let pos2 = 0;
      let num = 0;
      while ((pos2 = version3.indexOf(".", pos2 + 1)) > 0) {
        num++;
      }
      return version3 + ".0".repeat(2 - num);
    }
    function isUnreleasedVersion(version3, env) {
      const unreleasedLabel = _targets.unreleasedLabels[env];
      return !!unreleasedLabel && unreleasedLabel === version3.toString().toLowerCase();
    }
    function getLowestUnreleased(a, b, env) {
      const unreleasedLabel = _targets.unreleasedLabels[env];
      if (a === unreleasedLabel) {
        return b;
      }
      if (b === unreleasedLabel) {
        return a;
      }
      return semverMin(a, b);
    }
    function getHighestUnreleased(a, b, env) {
      return getLowestUnreleased(a, b, env) === a ? b : a;
    }
    function getLowestImplementedVersion(plugin2, environment) {
      const result = plugin2[environment];
      if (!result && environment === "android") {
        return plugin2.chrome;
      }
      return result;
    }
  }
});

// node_modules/@babel/helper-compilation-targets/lib/options.js
var require_options2 = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/options.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.TargetNames = void 0;
    var TargetNames = {
      node: "node",
      deno: "deno",
      chrome: "chrome",
      opera: "opera",
      edge: "edge",
      firefox: "firefox",
      safari: "safari",
      ie: "ie",
      ios: "ios",
      android: "android",
      electron: "electron",
      samsung: "samsung",
      rhino: "rhino"
    };
    exports.TargetNames = TargetNames;
  }
});

// node_modules/@babel/helper-compilation-targets/lib/pretty.js
var require_pretty = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/pretty.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.prettifyTargets = prettifyTargets;
    exports.prettifyVersion = prettifyVersion;
    var _semver = require_semver2();
    var _targets = require_targets();
    function prettifyVersion(version3) {
      if (typeof version3 !== "string") {
        return version3;
      }
      const {
        major,
        minor,
        patch: patch3
      } = _semver.parse(version3);
      const parts = [major];
      if (minor || patch3) {
        parts.push(minor);
      }
      if (patch3) {
        parts.push(patch3);
      }
      return parts.join(".");
    }
    function prettifyTargets(targets) {
      return Object.keys(targets).reduce((results, target) => {
        let value2 = targets[target];
        const unreleasedLabel = _targets.unreleasedLabels[target];
        if (typeof value2 === "string" && unreleasedLabel !== value2) {
          value2 = prettifyVersion(value2);
        }
        results[target] = value2;
        return results;
      }, {});
    }
  }
});

// node_modules/@babel/helper-compilation-targets/lib/debug.js
var require_debug = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/debug.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.getInclusionReasons = getInclusionReasons;
    var _semver = require_semver2();
    var _pretty = require_pretty();
    var _utils = require_utils3();
    function getInclusionReasons(item, targetVersions, list3) {
      const minVersions = list3[item] || {};
      return Object.keys(targetVersions).reduce((result, env) => {
        const minVersion = (0, _utils.getLowestImplementedVersion)(minVersions, env);
        const targetVersion = targetVersions[env];
        if (!minVersion) {
          result[env] = (0, _pretty.prettifyVersion)(targetVersion);
        } else {
          const minIsUnreleased = (0, _utils.isUnreleasedVersion)(minVersion, env);
          const targetIsUnreleased = (0, _utils.isUnreleasedVersion)(targetVersion, env);
          if (!targetIsUnreleased && (minIsUnreleased || _semver.lt(targetVersion.toString(), (0, _utils.semverify)(minVersion)))) {
            result[env] = (0, _pretty.prettifyVersion)(targetVersion);
          }
        }
        return result;
      }, {});
    }
  }
});

// node_modules/@babel/compat-data/data/plugins.json
var require_plugins = __commonJS({
  "node_modules/@babel/compat-data/data/plugins.json"(exports, module2) {
    module2.exports = {
      "transform-class-static-block": {
        chrome: "94",
        opera: "80",
        edge: "94",
        firefox: "93",
        node: "16.11",
        deno: "1.14",
        samsung: "17",
        electron: "15.0"
      },
      "proposal-class-static-block": {
        chrome: "94",
        opera: "80",
        edge: "94",
        firefox: "93",
        node: "16.11",
        deno: "1.14",
        samsung: "17",
        electron: "15.0"
      },
      "transform-private-property-in-object": {
        chrome: "91",
        opera: "77",
        edge: "91",
        firefox: "90",
        safari: "15",
        node: "16.9",
        deno: "1.9",
        ios: "15",
        samsung: "16",
        electron: "13.0"
      },
      "proposal-private-property-in-object": {
        chrome: "91",
        opera: "77",
        edge: "91",
        firefox: "90",
        safari: "15",
        node: "16.9",
        deno: "1.9",
        ios: "15",
        samsung: "16",
        electron: "13.0"
      },
      "transform-class-properties": {
        chrome: "74",
        opera: "62",
        edge: "79",
        firefox: "90",
        safari: "14.1",
        node: "12",
        deno: "1",
        ios: "15",
        samsung: "11",
        electron: "6.0"
      },
      "proposal-class-properties": {
        chrome: "74",
        opera: "62",
        edge: "79",
        firefox: "90",
        safari: "14.1",
        node: "12",
        deno: "1",
        ios: "15",
        samsung: "11",
        electron: "6.0"
      },
      "transform-private-methods": {
        chrome: "84",
        opera: "70",
        edge: "84",
        firefox: "90",
        safari: "15",
        node: "14.6",
        deno: "1",
        ios: "15",
        samsung: "14",
        electron: "10.0"
      },
      "proposal-private-methods": {
        chrome: "84",
        opera: "70",
        edge: "84",
        firefox: "90",
        safari: "15",
        node: "14.6",
        deno: "1",
        ios: "15",
        samsung: "14",
        electron: "10.0"
      },
      "transform-numeric-separator": {
        chrome: "75",
        opera: "62",
        edge: "79",
        firefox: "70",
        safari: "13",
        node: "12.5",
        deno: "1",
        ios: "13",
        samsung: "11",
        rhino: "1.7.14",
        electron: "6.0"
      },
      "proposal-numeric-separator": {
        chrome: "75",
        opera: "62",
        edge: "79",
        firefox: "70",
        safari: "13",
        node: "12.5",
        deno: "1",
        ios: "13",
        samsung: "11",
        rhino: "1.7.14",
        electron: "6.0"
      },
      "transform-logical-assignment-operators": {
        chrome: "85",
        opera: "71",
        edge: "85",
        firefox: "79",
        safari: "14",
        node: "15",
        deno: "1.2",
        ios: "14",
        samsung: "14",
        electron: "10.0"
      },
      "proposal-logical-assignment-operators": {
        chrome: "85",
        opera: "71",
        edge: "85",
        firefox: "79",
        safari: "14",
        node: "15",
        deno: "1.2",
        ios: "14",
        samsung: "14",
        electron: "10.0"
      },
      "transform-nullish-coalescing-operator": {
        chrome: "80",
        opera: "67",
        edge: "80",
        firefox: "72",
        safari: "13.1",
        node: "14",
        deno: "1",
        ios: "13.4",
        samsung: "13",
        electron: "8.0"
      },
      "proposal-nullish-coalescing-operator": {
        chrome: "80",
        opera: "67",
        edge: "80",
        firefox: "72",
        safari: "13.1",
        node: "14",
        deno: "1",
        ios: "13.4",
        samsung: "13",
        electron: "8.0"
      },
      "transform-optional-chaining": {
        chrome: "91",
        opera: "77",
        edge: "91",
        firefox: "74",
        safari: "13.1",
        node: "16.9",
        deno: "1.9",
        ios: "13.4",
        samsung: "16",
        electron: "13.0"
      },
      "proposal-optional-chaining": {
        chrome: "91",
        opera: "77",
        edge: "91",
        firefox: "74",
        safari: "13.1",
        node: "16.9",
        deno: "1.9",
        ios: "13.4",
        samsung: "16",
        electron: "13.0"
      },
      "transform-json-strings": {
        chrome: "66",
        opera: "53",
        edge: "79",
        firefox: "62",
        safari: "12",
        node: "10",
        deno: "1",
        ios: "12",
        samsung: "9",
        rhino: "1.7.14",
        electron: "3.0"
      },
      "proposal-json-strings": {
        chrome: "66",
        opera: "53",
        edge: "79",
        firefox: "62",
        safari: "12",
        node: "10",
        deno: "1",
        ios: "12",
        samsung: "9",
        rhino: "1.7.14",
        electron: "3.0"
      },
      "transform-optional-catch-binding": {
        chrome: "66",
        opera: "53",
        edge: "79",
        firefox: "58",
        safari: "11.1",
        node: "10",
        deno: "1",
        ios: "11.3",
        samsung: "9",
        electron: "3.0"
      },
      "proposal-optional-catch-binding": {
        chrome: "66",
        opera: "53",
        edge: "79",
        firefox: "58",
        safari: "11.1",
        node: "10",
        deno: "1",
        ios: "11.3",
        samsung: "9",
        electron: "3.0"
      },
      "transform-parameters": {
        chrome: "49",
        opera: "36",
        edge: "18",
        firefox: "53",
        node: "6",
        deno: "1",
        samsung: "5",
        electron: "0.37"
      },
      "transform-async-generator-functions": {
        chrome: "63",
        opera: "50",
        edge: "79",
        firefox: "57",
        safari: "12",
        node: "10",
        deno: "1",
        ios: "12",
        samsung: "8",
        electron: "3.0"
      },
      "proposal-async-generator-functions": {
        chrome: "63",
        opera: "50",
        edge: "79",
        firefox: "57",
        safari: "12",
        node: "10",
        deno: "1",
        ios: "12",
        samsung: "8",
        electron: "3.0"
      },
      "transform-object-rest-spread": {
        chrome: "60",
        opera: "47",
        edge: "79",
        firefox: "55",
        safari: "11.1",
        node: "8.3",
        deno: "1",
        ios: "11.3",
        samsung: "8",
        electron: "2.0"
      },
      "proposal-object-rest-spread": {
        chrome: "60",
        opera: "47",
        edge: "79",
        firefox: "55",
        safari: "11.1",
        node: "8.3",
        deno: "1",
        ios: "11.3",
        samsung: "8",
        electron: "2.0"
      },
      "transform-dotall-regex": {
        chrome: "62",
        opera: "49",
        edge: "79",
        firefox: "78",
        safari: "11.1",
        node: "8.10",
        deno: "1",
        ios: "11.3",
        samsung: "8",
        electron: "3.0"
      },
      "transform-unicode-property-regex": {
        chrome: "64",
        opera: "51",
        edge: "79",
        firefox: "78",
        safari: "11.1",
        node: "10",
        deno: "1",
        ios: "11.3",
        samsung: "9",
        electron: "3.0"
      },
      "proposal-unicode-property-regex": {
        chrome: "64",
        opera: "51",
        edge: "79",
        firefox: "78",
        safari: "11.1",
        node: "10",
        deno: "1",
        ios: "11.3",
        samsung: "9",
        electron: "3.0"
      },
      "transform-named-capturing-groups-regex": {
        chrome: "64",
        opera: "51",
        edge: "79",
        firefox: "78",
        safari: "11.1",
        node: "10",
        deno: "1",
        ios: "11.3",
        samsung: "9",
        electron: "3.0"
      },
      "transform-async-to-generator": {
        chrome: "55",
        opera: "42",
        edge: "15",
        firefox: "52",
        safari: "11",
        node: "7.6",
        deno: "1",
        ios: "11",
        samsung: "6",
        electron: "1.6"
      },
      "transform-exponentiation-operator": {
        chrome: "52",
        opera: "39",
        edge: "14",
        firefox: "52",
        safari: "10.1",
        node: "7",
        deno: "1",
        ios: "10.3",
        samsung: "6",
        rhino: "1.7.14",
        electron: "1.3"
      },
      "transform-template-literals": {
        chrome: "41",
        opera: "28",
        edge: "13",
        firefox: "34",
        safari: "13",
        node: "4",
        deno: "1",
        ios: "13",
        samsung: "3.4",
        electron: "0.21"
      },
      "transform-literals": {
        chrome: "44",
        opera: "31",
        edge: "12",
        firefox: "53",
        safari: "9",
        node: "4",
        deno: "1",
        ios: "9",
        samsung: "4",
        electron: "0.30"
      },
      "transform-function-name": {
        chrome: "51",
        opera: "38",
        edge: "79",
        firefox: "53",
        safari: "10",
        node: "6.5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "1.2"
      },
      "transform-arrow-functions": {
        chrome: "47",
        opera: "34",
        edge: "13",
        firefox: "43",
        safari: "10",
        node: "6",
        deno: "1",
        ios: "10",
        samsung: "5",
        rhino: "1.7.13",
        electron: "0.36"
      },
      "transform-block-scoped-functions": {
        chrome: "41",
        opera: "28",
        edge: "12",
        firefox: "46",
        safari: "10",
        node: "4",
        deno: "1",
        ie: "11",
        ios: "10",
        samsung: "3.4",
        electron: "0.21"
      },
      "transform-classes": {
        chrome: "46",
        opera: "33",
        edge: "13",
        firefox: "45",
        safari: "10",
        node: "5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "0.36"
      },
      "transform-object-super": {
        chrome: "46",
        opera: "33",
        edge: "13",
        firefox: "45",
        safari: "10",
        node: "5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "0.36"
      },
      "transform-shorthand-properties": {
        chrome: "43",
        opera: "30",
        edge: "12",
        firefox: "33",
        safari: "9",
        node: "4",
        deno: "1",
        ios: "9",
        samsung: "4",
        rhino: "1.7.14",
        electron: "0.27"
      },
      "transform-duplicate-keys": {
        chrome: "42",
        opera: "29",
        edge: "12",
        firefox: "34",
        safari: "9",
        node: "4",
        deno: "1",
        ios: "9",
        samsung: "3.4",
        electron: "0.25"
      },
      "transform-computed-properties": {
        chrome: "44",
        opera: "31",
        edge: "12",
        firefox: "34",
        safari: "7.1",
        node: "4",
        deno: "1",
        ios: "8",
        samsung: "4",
        electron: "0.30"
      },
      "transform-for-of": {
        chrome: "51",
        opera: "38",
        edge: "15",
        firefox: "53",
        safari: "10",
        node: "6.5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "1.2"
      },
      "transform-sticky-regex": {
        chrome: "49",
        opera: "36",
        edge: "13",
        firefox: "3",
        safari: "10",
        node: "6",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "0.37"
      },
      "transform-unicode-escapes": {
        chrome: "44",
        opera: "31",
        edge: "12",
        firefox: "53",
        safari: "9",
        node: "4",
        deno: "1",
        ios: "9",
        samsung: "4",
        electron: "0.30"
      },
      "transform-unicode-regex": {
        chrome: "50",
        opera: "37",
        edge: "13",
        firefox: "46",
        safari: "12",
        node: "6",
        deno: "1",
        ios: "12",
        samsung: "5",
        electron: "1.1"
      },
      "transform-spread": {
        chrome: "46",
        opera: "33",
        edge: "13",
        firefox: "45",
        safari: "10",
        node: "5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "0.36"
      },
      "transform-destructuring": {
        chrome: "51",
        opera: "38",
        edge: "15",
        firefox: "53",
        safari: "10",
        node: "6.5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "1.2"
      },
      "transform-block-scoping": {
        chrome: "49",
        opera: "36",
        edge: "14",
        firefox: "51",
        safari: "11",
        node: "6",
        deno: "1",
        ios: "11",
        samsung: "5",
        electron: "0.37"
      },
      "transform-typeof-symbol": {
        chrome: "38",
        opera: "25",
        edge: "12",
        firefox: "36",
        safari: "9",
        node: "0.12",
        deno: "1",
        ios: "9",
        samsung: "3",
        rhino: "1.7.13",
        electron: "0.20"
      },
      "transform-new-target": {
        chrome: "46",
        opera: "33",
        edge: "14",
        firefox: "41",
        safari: "10",
        node: "5",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "0.36"
      },
      "transform-regenerator": {
        chrome: "50",
        opera: "37",
        edge: "13",
        firefox: "53",
        safari: "10",
        node: "6",
        deno: "1",
        ios: "10",
        samsung: "5",
        electron: "1.1"
      },
      "transform-member-expression-literals": {
        chrome: "7",
        opera: "12",
        edge: "12",
        firefox: "2",
        safari: "5.1",
        node: "0.4",
        deno: "1",
        ie: "9",
        android: "4",
        ios: "6",
        phantom: "1.9",
        samsung: "1",
        rhino: "1.7.13",
        electron: "0.20"
      },
      "transform-property-literals": {
        chrome: "7",
        opera: "12",
        edge: "12",
        firefox: "2",
        safari: "5.1",
        node: "0.4",
        deno: "1",
        ie: "9",
        android: "4",
        ios: "6",
        phantom: "1.9",
        samsung: "1",
        rhino: "1.7.13",
        electron: "0.20"
      },
      "transform-reserved-words": {
        chrome: "13",
        opera: "10.50",
        edge: "12",
        firefox: "2",
        safari: "3.1",
        node: "0.6",
        deno: "1",
        ie: "9",
        android: "4.4",
        ios: "6",
        phantom: "1.9",
        samsung: "1",
        rhino: "1.7.13",
        electron: "0.20"
      },
      "transform-export-namespace-from": {
        chrome: "72",
        and_chr: "72",
        edge: "79",
        firefox: "80",
        and_ff: "80",
        node: "13.2",
        opera: "60",
        op_mob: "51",
        samsung: "11.0",
        android: "72",
        electron: "5.0"
      },
      "proposal-export-namespace-from": {
        chrome: "72",
        and_chr: "72",
        edge: "79",
        firefox: "80",
        and_ff: "80",
        node: "13.2",
        opera: "60",
        op_mob: "51",
        samsung: "11.0",
        android: "72",
        electron: "5.0"
      }
    };
  }
});

// node_modules/@babel/compat-data/plugins.js
var require_plugins2 = __commonJS({
  "node_modules/@babel/compat-data/plugins.js"(exports, module2) {
    module2.exports = require_plugins();
  }
});

// node_modules/@babel/helper-compilation-targets/lib/filter-items.js
var require_filter_items = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/filter-items.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = filterItems;
    exports.isRequired = isRequired;
    exports.targetsSupported = targetsSupported;
    var _semver = require_semver2();
    var _plugins = require_plugins2();
    var _utils = require_utils3();
    function targetsSupported(target, support) {
      const targetEnvironments = Object.keys(target);
      if (targetEnvironments.length === 0) {
        return false;
      }
      const unsupportedEnvironments = targetEnvironments.filter((environment) => {
        const lowestImplementedVersion = (0, _utils.getLowestImplementedVersion)(support, environment);
        if (!lowestImplementedVersion) {
          return true;
        }
        const lowestTargetedVersion = target[environment];
        if ((0, _utils.isUnreleasedVersion)(lowestTargetedVersion, environment)) {
          return false;
        }
        if ((0, _utils.isUnreleasedVersion)(lowestImplementedVersion, environment)) {
          return true;
        }
        if (!_semver.valid(lowestTargetedVersion.toString())) {
          throw new Error(`Invalid version passed for target "${environment}": "${lowestTargetedVersion}". Versions must be in semver format (major.minor.patch)`);
        }
        return _semver.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion.toString());
      });
      return unsupportedEnvironments.length === 0;
    }
    function isRequired(name2, targets, {
      compatData = _plugins,
      includes,
      excludes
    } = {}) {
      if (excludes != null && excludes.has(name2))
        return false;
      if (includes != null && includes.has(name2))
        return true;
      return !targetsSupported(targets, compatData[name2]);
    }
    function filterItems(list3, includes, excludes, targets, defaultIncludes, defaultExcludes, pluginSyntaxMap) {
      const result = /* @__PURE__ */ new Set();
      const options = {
        compatData: list3,
        includes,
        excludes
      };
      for (const item in list3) {
        if (isRequired(item, targets, options)) {
          result.add(item);
        } else if (pluginSyntaxMap) {
          const shippedProposalsSyntax = pluginSyntaxMap.get(item);
          if (shippedProposalsSyntax) {
            result.add(shippedProposalsSyntax);
          }
        }
      }
      if (defaultIncludes) {
        defaultIncludes.forEach((item) => !excludes.has(item) && result.add(item));
      }
      if (defaultExcludes) {
        defaultExcludes.forEach((item) => !includes.has(item) && result.delete(item));
      }
      return result;
    }
  }
});

// node_modules/@babel/helper-compilation-targets/lib/index.js
var require_lib19 = __commonJS({
  "node_modules/@babel/helper-compilation-targets/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "TargetNames", {
      enumerable: true,
      get: function() {
        return _options.TargetNames;
      }
    });
    exports.default = getTargets;
    Object.defineProperty(exports, "filterItems", {
      enumerable: true,
      get: function() {
        return _filterItems.default;
      }
    });
    Object.defineProperty(exports, "getInclusionReasons", {
      enumerable: true,
      get: function() {
        return _debug.getInclusionReasons;
      }
    });
    exports.isBrowsersQueryValid = isBrowsersQueryValid;
    Object.defineProperty(exports, "isRequired", {
      enumerable: true,
      get: function() {
        return _filterItems.isRequired;
      }
    });
    Object.defineProperty(exports, "prettifyTargets", {
      enumerable: true,
      get: function() {
        return _pretty.prettifyTargets;
      }
    });
    Object.defineProperty(exports, "unreleasedLabels", {
      enumerable: true,
      get: function() {
        return _targets.unreleasedLabels;
      }
    });
    var _browserslist = require_browserslist();
    var _helperValidatorOption = require_lib18();
    var _nativeModules = require_native_modules2();
    var _lruCache = require_lru_cache();
    var _utils = require_utils3();
    var _targets = require_targets();
    var _options = require_options2();
    var _pretty = require_pretty();
    var _debug = require_debug();
    var _filterItems = require_filter_items();
    var ESM_SUPPORT = _nativeModules["es6.module"];
    var v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
    function validateTargetNames(targets) {
      const validTargets = Object.keys(_options.TargetNames);
      for (const target of Object.keys(targets)) {
        if (!(target in _options.TargetNames)) {
          throw new Error(v.formatMessage(`'${target}' is not a valid target
- Did you mean '${(0, _helperValidatorOption.findSuggestion)(target, validTargets)}'?`));
        }
      }
      return targets;
    }
    function isBrowsersQueryValid(browsers) {
      return typeof browsers === "string" || Array.isArray(browsers) && browsers.every((b) => typeof b === "string");
    }
    function validateBrowsers(browsers) {
      v.invariant(browsers === void 0 || isBrowsersQueryValid(browsers), `'${String(browsers)}' is not a valid browserslist query`);
      return browsers;
    }
    function getLowestVersions(browsers) {
      return browsers.reduce((all4, browser) => {
        const [browserName, browserVersion] = browser.split(" ");
        const target = _targets.browserNameMap[browserName];
        if (!target) {
          return all4;
        }
        try {
          const splitVersion = browserVersion.split("-")[0].toLowerCase();
          const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, target);
          if (!all4[target]) {
            all4[target] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion);
            return all4;
          }
          const version3 = all4[target];
          const isUnreleased = (0, _utils.isUnreleasedVersion)(version3, target);
          if (isUnreleased && isSplitUnreleased) {
            all4[target] = (0, _utils.getLowestUnreleased)(version3, splitVersion, target);
          } else if (isUnreleased) {
            all4[target] = (0, _utils.semverify)(splitVersion);
          } else if (!isUnreleased && !isSplitUnreleased) {
            const parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
            all4[target] = (0, _utils.semverMin)(version3, parsedBrowserVersion);
          }
        } catch (e) {
        }
        return all4;
      }, {});
    }
    function outputDecimalWarning(decimalTargets) {
      if (!decimalTargets.length) {
        return;
      }
      console.warn("Warning, the following targets are using a decimal version:\n");
      decimalTargets.forEach(({
        target,
        value: value2
      }) => console.warn(`  ${target}: ${value2}`));
      console.warn(`
We recommend using a string for minor/patch versions to avoid numbers like 6.10
getting parsed as 6.1, which can lead to unexpected behavior.
`);
    }
    function semverifyTarget(target, value2) {
      try {
        return (0, _utils.semverify)(value2);
      } catch (error) {
        throw new Error(v.formatMessage(`'${value2}' is not a valid value for 'targets.${target}'.`));
      }
    }
    function nodeTargetParser(value2) {
      const parsed = value2 === true || value2 === "current" ? process.versions.node : semverifyTarget("node", value2);
      return ["node", parsed];
    }
    function defaultTargetParser(target, value2) {
      const version3 = (0, _utils.isUnreleasedVersion)(value2, target) ? value2.toLowerCase() : semverifyTarget(target, value2);
      return [target, version3];
    }
    function generateTargets(inputTargets) {
      const input = Object.assign({}, inputTargets);
      delete input.esmodules;
      delete input.browsers;
      return input;
    }
    function resolveTargets(queries, env) {
      const resolved = _browserslist(queries, {
        mobileToDesktop: true,
        env
      });
      return getLowestVersions(resolved);
    }
    var targetsCache = new _lruCache({
      max: 64
    });
    function resolveTargetsCached(queries, env) {
      const cacheKey = typeof queries === "string" ? queries : queries.join() + env;
      let cached = targetsCache.get(cacheKey);
      if (!cached) {
        cached = resolveTargets(queries, env);
        targetsCache.set(cacheKey, cached);
      }
      return Object.assign({}, cached);
    }
    function getTargets(inputTargets = {}, options = {}) {
      var _browsers, _browsers2;
      let {
        browsers,
        esmodules
      } = inputTargets;
      const {
        configPath = "."
      } = options;
      validateBrowsers(browsers);
      const input = generateTargets(inputTargets);
      let targets = validateTargetNames(input);
      const shouldParseBrowsers = !!browsers;
      const hasTargets = shouldParseBrowsers || Object.keys(targets).length > 0;
      const shouldSearchForConfig = !options.ignoreBrowserslistConfig && !hasTargets;
      if (!browsers && shouldSearchForConfig) {
        browsers = _browserslist.loadConfig({
          config: options.configFile,
          path: configPath,
          env: options.browserslistEnv
        });
        if (browsers == null) {
          {
            browsers = [];
          }
        }
      }
      if (esmodules && (esmodules !== "intersect" || !((_browsers = browsers) != null && _browsers.length))) {
        browsers = Object.keys(ESM_SUPPORT).map((browser) => `${browser} >= ${ESM_SUPPORT[browser]}`).join(", ");
        esmodules = false;
      }
      if ((_browsers2 = browsers) != null && _browsers2.length) {
        const queryBrowsers = resolveTargetsCached(browsers, options.browserslistEnv);
        if (esmodules === "intersect") {
          for (const browser of Object.keys(queryBrowsers)) {
            const version3 = queryBrowsers[browser];
            const esmSupportVersion = ESM_SUPPORT[browser];
            if (esmSupportVersion) {
              queryBrowsers[browser] = (0, _utils.getHighestUnreleased)(version3, (0, _utils.semverify)(esmSupportVersion), browser);
            } else {
              delete queryBrowsers[browser];
            }
          }
        }
        targets = Object.assign(queryBrowsers, targets);
      }
      const result = {};
      const decimalWarnings = [];
      for (const target of Object.keys(targets).sort()) {
        const value2 = targets[target];
        if (typeof value2 === "number" && value2 % 1 !== 0) {
          decimalWarnings.push({
            target,
            value: value2
          });
        }
        const [parsedTarget, parsedValue] = target === "node" ? nodeTargetParser(value2) : defaultTargetParser(target, value2);
        if (parsedValue) {
          result[parsedTarget] = parsedValue;
        }
      }
      outputDecimalWarning(decimalWarnings);
      return result;
    }
  }
});

// node_modules/@babel/core/lib/config/resolve-targets.js
var require_resolve_targets = __commonJS({
  "node_modules/@babel/core/lib/config/resolve-targets.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.resolveBrowserslistConfigFile = resolveBrowserslistConfigFile;
    exports.resolveTargets = resolveTargets;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _helperCompilationTargets() {
      const data3 = require_lib19();
      _helperCompilationTargets = function() {
        return data3;
      };
      return data3;
    }
    function resolveBrowserslistConfigFile(browserslistConfigFile, configFileDir) {
      return _path().resolve(configFileDir, browserslistConfigFile);
    }
    function resolveTargets(options, root4) {
      const optTargets = options.targets;
      let targets;
      if (typeof optTargets === "string" || Array.isArray(optTargets)) {
        targets = {
          browsers: optTargets
        };
      } else if (optTargets) {
        if ("esmodules" in optTargets) {
          targets = Object.assign({}, optTargets, {
            esmodules: "intersect"
          });
        } else {
          targets = optTargets;
        }
      }
      const {
        browserslistConfigFile
      } = options;
      let configFile;
      let ignoreBrowserslistConfig = false;
      if (typeof browserslistConfigFile === "string") {
        configFile = browserslistConfigFile;
      } else {
        ignoreBrowserslistConfig = browserslistConfigFile === false;
      }
      return (0, _helperCompilationTargets().default)(targets, {
        ignoreBrowserslistConfig,
        configFile,
        configPath: root4,
        browserslistEnv: options.browserslistEnv
      });
    }
  }
});

// node_modules/@babel/core/lib/config/config-descriptors.js
var require_config_descriptors = __commonJS({
  "node_modules/@babel/core/lib/config/config-descriptors.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.createCachedDescriptors = createCachedDescriptors;
    exports.createDescriptor = createDescriptor;
    exports.createUncachedDescriptors = createUncachedDescriptors;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _functional = require_functional();
    var _files = require_files();
    var _item = require_item();
    var _caching = require_caching();
    var _resolveTargets = require_resolve_targets();
    function isEqualDescriptor(a, b) {
      return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && (a.file && a.file.request) === (b.file && b.file.request) && (a.file && a.file.resolved) === (b.file && b.file.resolved);
    }
    function* handlerOf(value2) {
      return value2;
    }
    function optionsWithResolvedBrowserslistConfigFile(options, dirname) {
      if (typeof options.browserslistConfigFile === "string") {
        options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname);
      }
      return options;
    }
    function createCachedDescriptors(dirname, options, alias) {
      const {
        plugins,
        presets,
        passPerPreset
      } = options;
      return {
        options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
        plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => handlerOf([]),
        presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => handlerOf([])
      };
    }
    function createUncachedDescriptors(dirname, options, alias) {
      return {
        options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
        plugins: (0, _functional.once)(() => createPluginDescriptors(options.plugins || [], dirname, alias)),
        presets: (0, _functional.once)(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset))
      };
    }
    var PRESET_DESCRIPTOR_CACHE = /* @__PURE__ */ new WeakMap();
    var createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
      const dirname = cache.using((dir) => dir);
      return (0, _caching.makeStrongCacheSync)((alias) => (0, _caching.makeStrongCache)(function* (passPerPreset) {
        const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset);
        return descriptors.map((desc) => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc));
      }));
    });
    var PLUGIN_DESCRIPTOR_CACHE = /* @__PURE__ */ new WeakMap();
    var createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
      const dirname = cache.using((dir) => dir);
      return (0, _caching.makeStrongCache)(function* (alias) {
        const descriptors = yield* createPluginDescriptors(items, dirname, alias);
        return descriptors.map((desc) => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc));
      });
    });
    var DEFAULT_OPTIONS = {};
    function loadCachedDescriptor(cache, desc) {
      const {
        value: value2,
        options = DEFAULT_OPTIONS
      } = desc;
      if (options === false)
        return desc;
      let cacheByOptions = cache.get(value2);
      if (!cacheByOptions) {
        cacheByOptions = /* @__PURE__ */ new WeakMap();
        cache.set(value2, cacheByOptions);
      }
      let possibilities = cacheByOptions.get(options);
      if (!possibilities) {
        possibilities = [];
        cacheByOptions.set(options, possibilities);
      }
      if (possibilities.indexOf(desc) === -1) {
        const matches = possibilities.filter((possibility) => isEqualDescriptor(possibility, desc));
        if (matches.length > 0) {
          return matches[0];
        }
        possibilities.push(desc);
      }
      return desc;
    }
    function* createPresetDescriptors(items, dirname, alias, passPerPreset) {
      return yield* createDescriptors("preset", items, dirname, alias, passPerPreset);
    }
    function* createPluginDescriptors(items, dirname, alias) {
      return yield* createDescriptors("plugin", items, dirname, alias);
    }
    function* createDescriptors(type, items, dirname, alias, ownPass) {
      const descriptors = yield* _gensync().all(items.map((item, index2) => createDescriptor(item, dirname, {
        type,
        alias: `${alias}$${index2}`,
        ownPass: !!ownPass
      })));
      assertNoDuplicates(descriptors);
      return descriptors;
    }
    function* createDescriptor(pair, dirname, {
      type,
      alias,
      ownPass
    }) {
      const desc = (0, _item.getItemDescriptor)(pair);
      if (desc) {
        return desc;
      }
      let name2;
      let options;
      let value2 = pair;
      if (Array.isArray(value2)) {
        if (value2.length === 3) {
          [value2, options, name2] = value2;
        } else {
          [value2, options] = value2;
        }
      }
      let file = void 0;
      let filepath = null;
      if (typeof value2 === "string") {
        if (typeof type !== "string") {
          throw new Error("To resolve a string-based item, the type of item must be given");
        }
        const resolver2 = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
        const request = value2;
        ({
          filepath,
          value: value2
        } = yield* resolver2(value2, dirname));
        file = {
          request,
          resolved: filepath
        };
      }
      if (!value2) {
        throw new Error(`Unexpected falsy value: ${String(value2)}`);
      }
      if (typeof value2 === "object" && value2.__esModule) {
        if (value2.default) {
          value2 = value2.default;
        } else {
          throw new Error("Must export a default export when using ES6 modules.");
        }
      }
      if (typeof value2 !== "object" && typeof value2 !== "function") {
        throw new Error(`Unsupported format: ${typeof value2}. Expected an object or a function.`);
      }
      if (filepath !== null && typeof value2 === "object" && value2) {
        throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`);
      }
      return {
        name: name2,
        alias: filepath || alias,
        value: value2,
        options,
        dirname,
        ownPass,
        file
      };
    }
    function assertNoDuplicates(items) {
      const map = /* @__PURE__ */ new Map();
      for (const item of items) {
        if (typeof item.value !== "function")
          continue;
        let nameMap = map.get(item.value);
        if (!nameMap) {
          nameMap = /* @__PURE__ */ new Set();
          map.set(item.value, nameMap);
        }
        if (nameMap.has(item.name)) {
          const conflicts = items.filter((i) => i.value === item.value);
          throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n"));
        }
        nameMap.add(item.name);
      }
    }
  }
});

// node_modules/@babel/core/lib/config/item.js
var require_item = __commonJS({
  "node_modules/@babel/core/lib/config/item.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.createConfigItem = createConfigItem;
    exports.createItemFromDescriptor = createItemFromDescriptor;
    exports.getItemDescriptor = getItemDescriptor;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    var _configDescriptors = require_config_descriptors();
    function createItemFromDescriptor(desc) {
      return new ConfigItem(desc);
    }
    function* createConfigItem(value2, {
      dirname = ".",
      type
    } = {}) {
      const descriptor = yield* (0, _configDescriptors.createDescriptor)(value2, _path().resolve(dirname), {
        type,
        alias: "programmatic item"
      });
      return createItemFromDescriptor(descriptor);
    }
    var CONFIG_ITEM_BRAND = Symbol.for("@babel/core@7 - ConfigItem");
    function getItemDescriptor(item) {
      if (item != null && item[CONFIG_ITEM_BRAND]) {
        return item._descriptor;
      }
      return void 0;
    }
    var ConfigItem = class {
      constructor(descriptor) {
        this._descriptor = void 0;
        this[CONFIG_ITEM_BRAND] = true;
        this.value = void 0;
        this.options = void 0;
        this.dirname = void 0;
        this.name = void 0;
        this.file = void 0;
        this._descriptor = descriptor;
        Object.defineProperty(this, "_descriptor", {
          enumerable: false
        });
        Object.defineProperty(this, CONFIG_ITEM_BRAND, {
          enumerable: false
        });
        this.value = this._descriptor.value;
        this.options = this._descriptor.options;
        this.dirname = this._descriptor.dirname;
        this.name = this._descriptor.name;
        this.file = this._descriptor.file ? {
          request: this._descriptor.file.request,
          resolved: this._descriptor.file.resolved
        } : void 0;
        Object.freeze(this);
      }
    };
    Object.freeze(ConfigItem.prototype);
  }
});

// node_modules/@babel/core/lib/config/validation/removed.js
var require_removed = __commonJS({
  "node_modules/@babel/core/lib/config/validation/removed.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _default = {
      auxiliaryComment: {
        message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`"
      },
      blacklist: {
        message: "Put the specific transforms you want in the `plugins` option"
      },
      breakConfig: {
        message: "This is not a necessary option in Babel 6"
      },
      experimental: {
        message: "Put the specific transforms you want in the `plugins` option"
      },
      externalHelpers: {
        message: "Use the `external-helpers` plugin instead. Check out http://babeljs.io/docs/plugins/external-helpers/"
      },
      extra: {
        message: ""
      },
      jsxPragma: {
        message: "use the `pragma` option in the `react-jsx` plugin. Check out http://babeljs.io/docs/plugins/transform-react-jsx/"
      },
      loose: {
        message: "Specify the `loose` option for the relevant plugin you are using or use a preset that sets the option."
      },
      metadataUsedHelpers: {
        message: "Not required anymore as this is enabled by default"
      },
      modules: {
        message: "Use the corresponding module transform plugin in the `plugins` option. Check out http://babeljs.io/docs/plugins/#modules"
      },
      nonStandard: {
        message: "Use the `react-jsx` and `flow-strip-types` plugins to support JSX and Flow. Also check out the react preset http://babeljs.io/docs/plugins/preset-react/"
      },
      optional: {
        message: "Put the specific transforms you want in the `plugins` option"
      },
      sourceMapName: {
        message: "The `sourceMapName` option has been removed because it makes more sense for the tooling that calls Babel to assign `map.file` themselves."
      },
      stage: {
        message: "Check out the corresponding stage-x presets http://babeljs.io/docs/plugins/#presets"
      },
      whitelist: {
        message: "Put the specific transforms you want in the `plugins` option"
      },
      resolveModuleSource: {
        version: 6,
        message: "Use `babel-plugin-module-resolver@3`'s 'resolvePath' options"
      },
      metadata: {
        version: 6,
        message: "Generated plugin metadata is always included in the output result"
      },
      sourceMapTarget: {
        version: 6,
        message: "The `sourceMapTarget` option has been removed because it makes more sense for the tooling that calls Babel to assign `map.file` themselves."
      }
    };
    exports.default = _default;
  }
});

// node_modules/@babel/core/lib/config/validation/option-assertions.js
var require_option_assertions = __commonJS({
  "node_modules/@babel/core/lib/config/validation/option-assertions.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.access = access;
    exports.assertArray = assertArray;
    exports.assertAssumptions = assertAssumptions;
    exports.assertBabelrcSearch = assertBabelrcSearch;
    exports.assertBoolean = assertBoolean;
    exports.assertCallerMetadata = assertCallerMetadata;
    exports.assertCompact = assertCompact;
    exports.assertConfigApplicableTest = assertConfigApplicableTest;
    exports.assertConfigFileSearch = assertConfigFileSearch;
    exports.assertFunction = assertFunction;
    exports.assertIgnoreList = assertIgnoreList;
    exports.assertInputSourceMap = assertInputSourceMap;
    exports.assertObject = assertObject;
    exports.assertPluginList = assertPluginList;
    exports.assertRootMode = assertRootMode;
    exports.assertSourceMaps = assertSourceMaps;
    exports.assertSourceType = assertSourceType;
    exports.assertString = assertString;
    exports.assertTargets = assertTargets;
    exports.msg = msg;
    function _helperCompilationTargets() {
      const data3 = require_lib19();
      _helperCompilationTargets = function() {
        return data3;
      };
      return data3;
    }
    var _options = require_options3();
    function msg(loc) {
      switch (loc.type) {
        case "root":
          return ``;
        case "env":
          return `${msg(loc.parent)}.env["${loc.name}"]`;
        case "overrides":
          return `${msg(loc.parent)}.overrides[${loc.index}]`;
        case "option":
          return `${msg(loc.parent)}.${loc.name}`;
        case "access":
          return `${msg(loc.parent)}[${JSON.stringify(loc.name)}]`;
        default:
          throw new Error(`Assertion failure: Unknown type ${loc.type}`);
      }
    }
    function access(loc, name2) {
      return {
        type: "access",
        name: name2,
        parent: loc
      };
    }
    function assertRootMode(loc, value2) {
      if (value2 !== void 0 && value2 !== "root" && value2 !== "upward" && value2 !== "upward-optional") {
        throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`);
      }
      return value2;
    }
    function assertSourceMaps(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "boolean" && value2 !== "inline" && value2 !== "both") {
        throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`);
      }
      return value2;
    }
    function assertCompact(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "boolean" && value2 !== "auto") {
        throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`);
      }
      return value2;
    }
    function assertSourceType(loc, value2) {
      if (value2 !== void 0 && value2 !== "module" && value2 !== "script" && value2 !== "unambiguous") {
        throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`);
      }
      return value2;
    }
    function assertCallerMetadata(loc, value2) {
      const obj = assertObject(loc, value2);
      if (obj) {
        if (typeof obj.name !== "string") {
          throw new Error(`${msg(loc)} set but does not contain "name" property string`);
        }
        for (const prop of Object.keys(obj)) {
          const propLoc = access(loc, prop);
          const value3 = obj[prop];
          if (value3 != null && typeof value3 !== "boolean" && typeof value3 !== "string" && typeof value3 !== "number") {
            throw new Error(`${msg(propLoc)} must be null, undefined, a boolean, a string, or a number.`);
          }
        }
      }
      return value2;
    }
    function assertInputSourceMap(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "boolean" && (typeof value2 !== "object" || !value2)) {
        throw new Error(`${msg(loc)} must be a boolean, object, or undefined`);
      }
      return value2;
    }
    function assertString(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "string") {
        throw new Error(`${msg(loc)} must be a string, or undefined`);
      }
      return value2;
    }
    function assertFunction(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "function") {
        throw new Error(`${msg(loc)} must be a function, or undefined`);
      }
      return value2;
    }
    function assertBoolean(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "boolean") {
        throw new Error(`${msg(loc)} must be a boolean, or undefined`);
      }
      return value2;
    }
    function assertObject(loc, value2) {
      if (value2 !== void 0 && (typeof value2 !== "object" || Array.isArray(value2) || !value2)) {
        throw new Error(`${msg(loc)} must be an object, or undefined`);
      }
      return value2;
    }
    function assertArray(loc, value2) {
      if (value2 != null && !Array.isArray(value2)) {
        throw new Error(`${msg(loc)} must be an array, or undefined`);
      }
      return value2;
    }
    function assertIgnoreList(loc, value2) {
      const arr = assertArray(loc, value2);
      if (arr) {
        arr.forEach((item, i) => assertIgnoreItem(access(loc, i), item));
      }
      return arr;
    }
    function assertIgnoreItem(loc, value2) {
      if (typeof value2 !== "string" && typeof value2 !== "function" && !(value2 instanceof RegExp)) {
        throw new Error(`${msg(loc)} must be an array of string/Function/RegExp values, or undefined`);
      }
      return value2;
    }
    function assertConfigApplicableTest(loc, value2) {
      if (value2 === void 0) {
        return value2;
      }
      if (Array.isArray(value2)) {
        value2.forEach((item, i) => {
          if (!checkValidTest(item)) {
            throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
          }
        });
      } else if (!checkValidTest(value2)) {
        throw new Error(`${msg(loc)} must be a string/Function/RegExp, or an array of those`);
      }
      return value2;
    }
    function checkValidTest(value2) {
      return typeof value2 === "string" || typeof value2 === "function" || value2 instanceof RegExp;
    }
    function assertConfigFileSearch(loc, value2) {
      if (value2 !== void 0 && typeof value2 !== "boolean" && typeof value2 !== "string") {
        throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, got ${JSON.stringify(value2)}`);
      }
      return value2;
    }
    function assertBabelrcSearch(loc, value2) {
      if (value2 === void 0 || typeof value2 === "boolean") {
        return value2;
      }
      if (Array.isArray(value2)) {
        value2.forEach((item, i) => {
          if (!checkValidTest(item)) {
            throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
          }
        });
      } else if (!checkValidTest(value2)) {
        throw new Error(`${msg(loc)} must be a undefined, a boolean, a string/Function/RegExp or an array of those, got ${JSON.stringify(value2)}`);
      }
      return value2;
    }
    function assertPluginList(loc, value2) {
      const arr = assertArray(loc, value2);
      if (arr) {
        arr.forEach((item, i) => assertPluginItem(access(loc, i), item));
      }
      return arr;
    }
    function assertPluginItem(loc, value2) {
      if (Array.isArray(value2)) {
        if (value2.length === 0) {
          throw new Error(`${msg(loc)} must include an object`);
        }
        if (value2.length > 3) {
          throw new Error(`${msg(loc)} may only be a two-tuple or three-tuple`);
        }
        assertPluginTarget(access(loc, 0), value2[0]);
        if (value2.length > 1) {
          const opts = value2[1];
          if (opts !== void 0 && opts !== false && (typeof opts !== "object" || Array.isArray(opts) || opts === null)) {
            throw new Error(`${msg(access(loc, 1))} must be an object, false, or undefined`);
          }
        }
        if (value2.length === 3) {
          const name2 = value2[2];
          if (name2 !== void 0 && typeof name2 !== "string") {
            throw new Error(`${msg(access(loc, 2))} must be a string, or undefined`);
          }
        }
      } else {
        assertPluginTarget(loc, value2);
      }
      return value2;
    }
    function assertPluginTarget(loc, value2) {
      if ((typeof value2 !== "object" || !value2) && typeof value2 !== "string" && typeof value2 !== "function") {
        throw new Error(`${msg(loc)} must be a string, object, function`);
      }
      return value2;
    }
    function assertTargets(loc, value2) {
      if ((0, _helperCompilationTargets().isBrowsersQueryValid)(value2))
        return value2;
      if (typeof value2 !== "object" || !value2 || Array.isArray(value2)) {
        throw new Error(`${msg(loc)} must be a string, an array of strings or an object`);
      }
      const browsersLoc = access(loc, "browsers");
      const esmodulesLoc = access(loc, "esmodules");
      assertBrowsersList(browsersLoc, value2.browsers);
      assertBoolean(esmodulesLoc, value2.esmodules);
      for (const key2 of Object.keys(value2)) {
        const val = value2[key2];
        const subLoc = access(loc, key2);
        if (key2 === "esmodules")
          assertBoolean(subLoc, val);
        else if (key2 === "browsers")
          assertBrowsersList(subLoc, val);
        else if (!Object.hasOwnProperty.call(_helperCompilationTargets().TargetNames, key2)) {
          const validTargets = Object.keys(_helperCompilationTargets().TargetNames).join(", ");
          throw new Error(`${msg(subLoc)} is not a valid target. Supported targets are ${validTargets}`);
        } else
          assertBrowserVersion(subLoc, val);
      }
      return value2;
    }
    function assertBrowsersList(loc, value2) {
      if (value2 !== void 0 && !(0, _helperCompilationTargets().isBrowsersQueryValid)(value2)) {
        throw new Error(`${msg(loc)} must be undefined, a string or an array of strings`);
      }
    }
    function assertBrowserVersion(loc, value2) {
      if (typeof value2 === "number" && Math.round(value2) === value2)
        return;
      if (typeof value2 === "string")
        return;
      throw new Error(`${msg(loc)} must be a string or an integer number`);
    }
    function assertAssumptions(loc, value2) {
      if (value2 === void 0)
        return;
      if (typeof value2 !== "object" || value2 === null) {
        throw new Error(`${msg(loc)} must be an object or undefined.`);
      }
      let root4 = loc;
      do {
        root4 = root4.parent;
      } while (root4.type !== "root");
      const inPreset = root4.source === "preset";
      for (const name2 of Object.keys(value2)) {
        const subLoc = access(loc, name2);
        if (!_options.assumptionsNames.has(name2)) {
          throw new Error(`${msg(subLoc)} is not a supported assumption.`);
        }
        if (typeof value2[name2] !== "boolean") {
          throw new Error(`${msg(subLoc)} must be a boolean.`);
        }
        if (inPreset && value2[name2] === false) {
          throw new Error(`${msg(subLoc)} cannot be set to 'false' inside presets.`);
        }
      }
      return value2;
    }
  }
});

// node_modules/@babel/core/lib/config/validation/options.js
var require_options3 = __commonJS({
  "node_modules/@babel/core/lib/config/validation/options.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.assumptionsNames = void 0;
    exports.checkNoUnwrappedItemOptionPairs = checkNoUnwrappedItemOptionPairs;
    exports.validate = validate;
    var _removed = require_removed();
    var _optionAssertions = require_option_assertions();
    var _configError = require_config_error();
    var ROOT_VALIDATORS = {
      cwd: _optionAssertions.assertString,
      root: _optionAssertions.assertString,
      rootMode: _optionAssertions.assertRootMode,
      configFile: _optionAssertions.assertConfigFileSearch,
      caller: _optionAssertions.assertCallerMetadata,
      filename: _optionAssertions.assertString,
      filenameRelative: _optionAssertions.assertString,
      code: _optionAssertions.assertBoolean,
      ast: _optionAssertions.assertBoolean,
      cloneInputAst: _optionAssertions.assertBoolean,
      envName: _optionAssertions.assertString
    };
    var BABELRC_VALIDATORS = {
      babelrc: _optionAssertions.assertBoolean,
      babelrcRoots: _optionAssertions.assertBabelrcSearch
    };
    var NONPRESET_VALIDATORS = {
      extends: _optionAssertions.assertString,
      ignore: _optionAssertions.assertIgnoreList,
      only: _optionAssertions.assertIgnoreList,
      targets: _optionAssertions.assertTargets,
      browserslistConfigFile: _optionAssertions.assertConfigFileSearch,
      browserslistEnv: _optionAssertions.assertString
    };
    var COMMON_VALIDATORS = {
      inputSourceMap: _optionAssertions.assertInputSourceMap,
      presets: _optionAssertions.assertPluginList,
      plugins: _optionAssertions.assertPluginList,
      passPerPreset: _optionAssertions.assertBoolean,
      assumptions: _optionAssertions.assertAssumptions,
      env: assertEnvSet,
      overrides: assertOverridesList,
      test: _optionAssertions.assertConfigApplicableTest,
      include: _optionAssertions.assertConfigApplicableTest,
      exclude: _optionAssertions.assertConfigApplicableTest,
      retainLines: _optionAssertions.assertBoolean,
      comments: _optionAssertions.assertBoolean,
      shouldPrintComment: _optionAssertions.assertFunction,
      compact: _optionAssertions.assertCompact,
      minified: _optionAssertions.assertBoolean,
      auxiliaryCommentBefore: _optionAssertions.assertString,
      auxiliaryCommentAfter: _optionAssertions.assertString,
      sourceType: _optionAssertions.assertSourceType,
      wrapPluginVisitorMethod: _optionAssertions.assertFunction,
      highlightCode: _optionAssertions.assertBoolean,
      sourceMaps: _optionAssertions.assertSourceMaps,
      sourceMap: _optionAssertions.assertSourceMaps,
      sourceFileName: _optionAssertions.assertString,
      sourceRoot: _optionAssertions.assertString,
      parserOpts: _optionAssertions.assertObject,
      generatorOpts: _optionAssertions.assertObject
    };
    {
      Object.assign(COMMON_VALIDATORS, {
        getModuleId: _optionAssertions.assertFunction,
        moduleRoot: _optionAssertions.assertString,
        moduleIds: _optionAssertions.assertBoolean,
        moduleId: _optionAssertions.assertString
      });
    }
    var knownAssumptions = ["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noDocumentAll", "noIncompleteNsImportDetection", "noNewArrows", "objectRestNoSymbols", "privateFieldsAsSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"];
    var assumptionsNames = new Set(knownAssumptions);
    exports.assumptionsNames = assumptionsNames;
    function getSource(loc) {
      return loc.type === "root" ? loc.source : getSource(loc.parent);
    }
    function validate(type, opts, filename) {
      try {
        return validateNested({
          type: "root",
          source: type
        }, opts);
      } catch (error) {
        const configError = new _configError.default(error.message, filename);
        if (error.code)
          configError.code = error.code;
        throw configError;
      }
    }
    function validateNested(loc, opts) {
      const type = getSource(loc);
      assertNoDuplicateSourcemap(opts);
      Object.keys(opts).forEach((key2) => {
        const optLoc = {
          type: "option",
          name: key2,
          parent: loc
        };
        if (type === "preset" && NONPRESET_VALIDATORS[key2]) {
          throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in preset options`);
        }
        if (type !== "arguments" && ROOT_VALIDATORS[key2]) {
          throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options`);
        }
        if (type !== "arguments" && type !== "configfile" && BABELRC_VALIDATORS[key2]) {
          if (type === "babelrcfile" || type === "extendsfile") {
            throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in .babelrc or "extends"ed files, only in root programmatic options, or babel.config.js/config file options`);
          }
          throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`);
        }
        const validator = COMMON_VALIDATORS[key2] || NONPRESET_VALIDATORS[key2] || BABELRC_VALIDATORS[key2] || ROOT_VALIDATORS[key2] || throwUnknownError;
        validator(optLoc, opts[key2]);
      });
      return opts;
    }
    function throwUnknownError(loc) {
      const key2 = loc.name;
      if (_removed.default[key2]) {
        const {
          message,
          version: version3 = 5
        } = _removed.default[key2];
        throw new Error(`Using removed Babel ${version3} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
      } else {
        const unknownOptErr = new Error(`Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`);
        unknownOptErr.code = "BABEL_UNKNOWN_OPTION";
        throw unknownOptErr;
      }
    }
    function has2(obj, key2) {
      return Object.prototype.hasOwnProperty.call(obj, key2);
    }
    function assertNoDuplicateSourcemap(opts) {
      if (has2(opts, "sourceMap") && has2(opts, "sourceMaps")) {
        throw new Error(".sourceMap is an alias for .sourceMaps, cannot use both");
      }
    }
    function assertEnvSet(loc, value2) {
      if (loc.parent.type === "env") {
        throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside of another .env block`);
      }
      const parent = loc.parent;
      const obj = (0, _optionAssertions.assertObject)(loc, value2);
      if (obj) {
        for (const envName of Object.keys(obj)) {
          const env = (0, _optionAssertions.assertObject)((0, _optionAssertions.access)(loc, envName), obj[envName]);
          if (!env)
            continue;
          const envLoc = {
            type: "env",
            name: envName,
            parent
          };
          validateNested(envLoc, env);
        }
      }
      return obj;
    }
    function assertOverridesList(loc, value2) {
      if (loc.parent.type === "env") {
        throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .env block`);
      }
      if (loc.parent.type === "overrides") {
        throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .overrides block`);
      }
      const parent = loc.parent;
      const arr = (0, _optionAssertions.assertArray)(loc, value2);
      if (arr) {
        for (const [index2, item] of arr.entries()) {
          const objLoc = (0, _optionAssertions.access)(loc, index2);
          const env = (0, _optionAssertions.assertObject)(objLoc, item);
          if (!env)
            throw new Error(`${(0, _optionAssertions.msg)(objLoc)} must be an object`);
          const overridesLoc = {
            type: "overrides",
            index: index2,
            parent
          };
          validateNested(overridesLoc, env);
        }
      }
      return arr;
    }
    function checkNoUnwrappedItemOptionPairs(items, index2, type, e) {
      if (index2 === 0)
        return;
      const lastItem = items[index2 - 1];
      const thisItem = items[index2];
      if (lastItem.file && lastItem.options === void 0 && typeof thisItem.value === "object") {
        e.message += `
- Maybe you meant to use
"${type}s": [
  ["${lastItem.file.request}", ${JSON.stringify(thisItem.value, void 0, 2)}]
]
To be a valid ${type}, its name and options should be wrapped in a pair of brackets`;
      }
    }
  }
});

// node_modules/@babel/core/lib/config/pattern-to-regex.js
var require_pattern_to_regex = __commonJS({
  "node_modules/@babel/core/lib/config/pattern-to-regex.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = pathToPattern;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    var sep = `\\${_path().sep}`;
    var endSep = `(?:${sep}|$)`;
    var substitution = `[^${sep}]+`;
    var starPat = `(?:${substitution}${sep})`;
    var starPatLast = `(?:${substitution}${endSep})`;
    var starStarPat = `${starPat}*?`;
    var starStarPatLast = `${starPat}*?${starPatLast}?`;
    function escapeRegExp(string3) {
      return string3.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
    }
    function pathToPattern(pattern, dirname) {
      const parts = _path().resolve(dirname, pattern).split(_path().sep);
      return new RegExp(["^", ...parts.map((part, i) => {
        const last = i === parts.length - 1;
        if (part === "**")
          return last ? starStarPatLast : starStarPat;
        if (part === "*")
          return last ? starPatLast : starPat;
        if (part.indexOf("*.") === 0) {
          return substitution + escapeRegExp(part.slice(1)) + (last ? endSep : sep);
        }
        return escapeRegExp(part) + (last ? endSep : sep);
      })].join(""));
    }
  }
});

// node_modules/@babel/core/lib/config/printer.js
var require_printer2 = __commonJS({
  "node_modules/@babel/core/lib/config/printer.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ConfigPrinter = exports.ChainFormatter = void 0;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var ChainFormatter = {
      Programmatic: 0,
      Config: 1
    };
    exports.ChainFormatter = ChainFormatter;
    var Formatter = {
      title(type, callerName, filepath) {
        let title = "";
        if (type === ChainFormatter.Programmatic) {
          title = "programmatic options";
          if (callerName) {
            title += " from " + callerName;
          }
        } else {
          title = "config " + filepath;
        }
        return title;
      },
      loc(index2, envName) {
        let loc = "";
        if (index2 != null) {
          loc += `.overrides[${index2}]`;
        }
        if (envName != null) {
          loc += `.env["${envName}"]`;
        }
        return loc;
      },
      *optionsAndDescriptors(opt) {
        const content3 = Object.assign({}, opt.options);
        delete content3.overrides;
        delete content3.env;
        const pluginDescriptors = [...yield* opt.plugins()];
        if (pluginDescriptors.length) {
          content3.plugins = pluginDescriptors.map((d) => descriptorToConfig(d));
        }
        const presetDescriptors = [...yield* opt.presets()];
        if (presetDescriptors.length) {
          content3.presets = [...presetDescriptors].map((d) => descriptorToConfig(d));
        }
        return JSON.stringify(content3, void 0, 2);
      }
    };
    function descriptorToConfig(d) {
      var _d$file;
      let name2 = (_d$file = d.file) == null ? void 0 : _d$file.request;
      if (name2 == null) {
        if (typeof d.value === "object") {
          name2 = d.value;
        } else if (typeof d.value === "function") {
          name2 = `[Function: ${d.value.toString().slice(0, 50)} ... ]`;
        }
      }
      if (name2 == null) {
        name2 = "[Unknown]";
      }
      if (d.options === void 0) {
        return name2;
      } else if (d.name == null) {
        return [name2, d.options];
      } else {
        return [name2, d.options, d.name];
      }
    }
    var ConfigPrinter = class {
      constructor() {
        this._stack = [];
      }
      configure(enabled, type, {
        callerName,
        filepath
      }) {
        if (!enabled)
          return () => {
          };
        return (content3, index2, envName) => {
          this._stack.push({
            type,
            callerName,
            filepath,
            content: content3,
            index: index2,
            envName
          });
        };
      }
      static *format(config) {
        let title = Formatter.title(config.type, config.callerName, config.filepath);
        const loc = Formatter.loc(config.index, config.envName);
        if (loc)
          title += ` ${loc}`;
        const content3 = yield* Formatter.optionsAndDescriptors(config.content);
        return `${title}
${content3}`;
      }
      *output() {
        if (this._stack.length === 0)
          return "";
        const configs = yield* _gensync().all(this._stack.map((s) => ConfigPrinter.format(s)));
        return configs.join("\n\n");
      }
    };
    exports.ConfigPrinter = ConfigPrinter;
  }
});

// node_modules/@babel/core/lib/config/config-chain.js
var require_config_chain = __commonJS({
  "node_modules/@babel/core/lib/config/config-chain.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.buildPresetChain = buildPresetChain;
    exports.buildPresetChainWalker = void 0;
    exports.buildRootChain = buildRootChain;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _debug() {
      const data3 = require_src();
      _debug = function() {
        return data3;
      };
      return data3;
    }
    var _options = require_options3();
    var _patternToRegex = require_pattern_to_regex();
    var _printer = require_printer2();
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var _configError = require_config_error();
    var _files = require_files();
    var _caching = require_caching();
    var _configDescriptors = require_config_descriptors();
    var debug = _debug()("babel:config:config-chain");
    function* buildPresetChain(arg, context) {
      const chain = yield* buildPresetChainWalker(arg, context);
      if (!chain)
        return null;
      return {
        plugins: dedupDescriptors(chain.plugins),
        presets: dedupDescriptors(chain.presets),
        options: chain.options.map((o) => normalizeOptions(o)),
        files: /* @__PURE__ */ new Set()
      };
    }
    var buildPresetChainWalker = makeChainWalker({
      root: (preset) => loadPresetDescriptors(preset),
      env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
      overrides: (preset, index2) => loadPresetOverridesDescriptors(preset)(index2),
      overridesEnv: (preset, index2, envName) => loadPresetOverridesEnvDescriptors(preset)(index2)(envName),
      createLogger: () => () => {
      }
    });
    exports.buildPresetChainWalker = buildPresetChainWalker;
    var loadPresetDescriptors = (0, _caching.makeWeakCacheSync)((preset) => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
    var loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)((preset) => (0, _caching.makeStrongCacheSync)((envName) => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
    var loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)((preset) => (0, _caching.makeStrongCacheSync)((index2) => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index2)));
    var loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)((preset) => (0, _caching.makeStrongCacheSync)((index2) => (0, _caching.makeStrongCacheSync)((envName) => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index2, envName))));
    function* buildRootChain(opts, context) {
      let configReport, babelRcReport;
      const programmaticLogger = new _printer.ConfigPrinter();
      const programmaticChain = yield* loadProgrammaticChain({
        options: opts,
        dirname: context.cwd
      }, context, void 0, programmaticLogger);
      if (!programmaticChain)
        return null;
      const programmaticReport = yield* programmaticLogger.output();
      let configFile;
      if (typeof opts.configFile === "string") {
        configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
      } else if (opts.configFile !== false) {
        configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller);
      }
      let {
        babelrc,
        babelrcRoots
      } = opts;
      let babelrcRootsDirectory = context.cwd;
      const configFileChain = emptyChain();
      const configFileLogger = new _printer.ConfigPrinter();
      if (configFile) {
        const validatedFile = validateConfigFile(configFile);
        const result = yield* loadFileChain(validatedFile, context, void 0, configFileLogger);
        if (!result)
          return null;
        configReport = yield* configFileLogger.output();
        if (babelrc === void 0) {
          babelrc = validatedFile.options.babelrc;
        }
        if (babelrcRoots === void 0) {
          babelrcRootsDirectory = validatedFile.dirname;
          babelrcRoots = validatedFile.options.babelrcRoots;
        }
        mergeChain(configFileChain, result);
      }
      let ignoreFile, babelrcFile;
      let isIgnored = false;
      const fileChain = emptyChain();
      if ((babelrc === true || babelrc === void 0) && typeof context.filename === "string") {
        const pkgData = yield* (0, _files.findPackageData)(context.filename);
        if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {
          ({
            ignore: ignoreFile,
            config: babelrcFile
          } = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
          if (ignoreFile) {
            fileChain.files.add(ignoreFile.filepath);
          }
          if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
            isIgnored = true;
          }
          if (babelrcFile && !isIgnored) {
            const validatedFile = validateBabelrcFile(babelrcFile);
            const babelrcLogger = new _printer.ConfigPrinter();
            const result = yield* loadFileChain(validatedFile, context, void 0, babelrcLogger);
            if (!result) {
              isIgnored = true;
            } else {
              babelRcReport = yield* babelrcLogger.output();
              mergeChain(fileChain, result);
            }
          }
          if (babelrcFile && isIgnored) {
            fileChain.files.add(babelrcFile.filepath);
          }
        }
      }
      if (context.showConfig) {
        console.log(`Babel configs on "${context.filename}" (ascending priority):
` + [configReport, babelRcReport, programmaticReport].filter((x) => !!x).join("\n\n") + "\n-----End Babel configs-----");
      }
      const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
      return {
        plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),
        presets: isIgnored ? [] : dedupDescriptors(chain.presets),
        options: isIgnored ? [] : chain.options.map((o) => normalizeOptions(o)),
        fileHandling: isIgnored ? "ignored" : "transpile",
        ignore: ignoreFile || void 0,
        babelrc: babelrcFile || void 0,
        config: configFile || void 0,
        files: chain.files
      };
    }
    function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) {
      if (typeof babelrcRoots === "boolean")
        return babelrcRoots;
      const absoluteRoot = context.root;
      if (babelrcRoots === void 0) {
        return pkgData.directories.indexOf(absoluteRoot) !== -1;
      }
      let babelrcPatterns = babelrcRoots;
      if (!Array.isArray(babelrcPatterns)) {
        babelrcPatterns = [babelrcPatterns];
      }
      babelrcPatterns = babelrcPatterns.map((pat) => {
        return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat;
      });
      if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
        return pkgData.directories.indexOf(absoluteRoot) !== -1;
      }
      return babelrcPatterns.some((pat) => {
        if (typeof pat === "string") {
          pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
        }
        return pkgData.directories.some((directory) => {
          return matchPattern(pat, babelrcRootsDirectory, directory, context);
        });
      });
    }
    var validateConfigFile = (0, _caching.makeWeakCacheSync)((file) => ({
      filepath: file.filepath,
      dirname: file.dirname,
      options: (0, _options.validate)("configfile", file.options, file.filepath)
    }));
    var validateBabelrcFile = (0, _caching.makeWeakCacheSync)((file) => ({
      filepath: file.filepath,
      dirname: file.dirname,
      options: (0, _options.validate)("babelrcfile", file.options, file.filepath)
    }));
    var validateExtendFile = (0, _caching.makeWeakCacheSync)((file) => ({
      filepath: file.filepath,
      dirname: file.dirname,
      options: (0, _options.validate)("extendsfile", file.options, file.filepath)
    }));
    var loadProgrammaticChain = makeChainWalker({
      root: (input) => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
      env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
      overrides: (input, index2) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index2),
      overridesEnv: (input, index2, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index2, envName),
      createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)
    });
    var loadFileChainWalker = makeChainWalker({
      root: (file) => loadFileDescriptors(file),
      env: (file, envName) => loadFileEnvDescriptors(file)(envName),
      overrides: (file, index2) => loadFileOverridesDescriptors(file)(index2),
      overridesEnv: (file, index2, envName) => loadFileOverridesEnvDescriptors(file)(index2)(envName),
      createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger)
    });
    function* loadFileChain(input, context, files, baseLogger) {
      const chain = yield* loadFileChainWalker(input, context, files, baseLogger);
      if (chain) {
        chain.files.add(input.filepath);
      }
      return chain;
    }
    var loadFileDescriptors = (0, _caching.makeWeakCacheSync)((file) => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
    var loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)((file) => (0, _caching.makeStrongCacheSync)((envName) => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
    var loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)((file) => (0, _caching.makeStrongCacheSync)((index2) => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index2)));
    var loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)((file) => (0, _caching.makeStrongCacheSync)((index2) => (0, _caching.makeStrongCacheSync)((envName) => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index2, envName))));
    function buildFileLogger(filepath, context, baseLogger) {
      if (!baseLogger) {
        return () => {
        };
      }
      return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
        filepath
      });
    }
    function buildRootDescriptors({
      dirname,
      options
    }, alias, descriptors) {
      return descriptors(dirname, options, alias);
    }
    function buildProgrammaticLogger(_, context, baseLogger) {
      var _context$caller;
      if (!baseLogger) {
        return () => {
        };
      }
      return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
        callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name
      });
    }
    function buildEnvDescriptors({
      dirname,
      options
    }, alias, descriptors, envName) {
      const opts = options.env && options.env[envName];
      return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
    }
    function buildOverrideDescriptors({
      dirname,
      options
    }, alias, descriptors, index2) {
      const opts = options.overrides && options.overrides[index2];
      if (!opts)
        throw new Error("Assertion failure - missing override");
      return descriptors(dirname, opts, `${alias}.overrides[${index2}]`);
    }
    function buildOverrideEnvDescriptors({
      dirname,
      options
    }, alias, descriptors, index2, envName) {
      const override = options.overrides && options.overrides[index2];
      if (!override)
        throw new Error("Assertion failure - missing override");
      const opts = override.env && override.env[envName];
      return opts ? descriptors(dirname, opts, `${alias}.overrides[${index2}].env["${envName}"]`) : null;
    }
    function makeChainWalker({
      root: root4,
      env,
      overrides,
      overridesEnv,
      createLogger
    }) {
      return function* chainWalker(input, context, files = /* @__PURE__ */ new Set(), baseLogger) {
        const {
          dirname
        } = input;
        const flattenedConfigs = [];
        const rootOpts = root4(input);
        if (configIsApplicable(rootOpts, dirname, context, input.filepath)) {
          flattenedConfigs.push({
            config: rootOpts,
            envName: void 0,
            index: void 0
          });
          const envOpts = env(input, context.envName);
          if (envOpts && configIsApplicable(envOpts, dirname, context, input.filepath)) {
            flattenedConfigs.push({
              config: envOpts,
              envName: context.envName,
              index: void 0
            });
          }
          (rootOpts.options.overrides || []).forEach((_, index2) => {
            const overrideOps = overrides(input, index2);
            if (configIsApplicable(overrideOps, dirname, context, input.filepath)) {
              flattenedConfigs.push({
                config: overrideOps,
                index: index2,
                envName: void 0
              });
              const overrideEnvOpts = overridesEnv(input, index2, context.envName);
              if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context, input.filepath)) {
                flattenedConfigs.push({
                  config: overrideEnvOpts,
                  index: index2,
                  envName: context.envName
                });
              }
            }
          });
        }
        if (flattenedConfigs.some(({
          config: {
            options: {
              ignore: ignore3,
              only
            }
          }
        }) => shouldIgnore(context, ignore3, only, dirname))) {
          return null;
        }
        const chain = emptyChain();
        const logger = createLogger(input, context, baseLogger);
        for (const {
          config,
          index: index2,
          envName
        } of flattenedConfigs) {
          if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) {
            return null;
          }
          logger(config, index2, envName);
          yield* mergeChainOpts(chain, config);
        }
        return chain;
      };
    }
    function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) {
      if (opts.extends === void 0)
        return true;
      const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
      if (files.has(file)) {
        throw new Error(`Configuration cycle detected loading ${file.filepath}.
File already loaded following the config chain:
` + Array.from(files, (file2) => ` - ${file2.filepath}`).join("\n"));
      }
      files.add(file);
      const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger);
      files.delete(file);
      if (!fileChain)
        return false;
      mergeChain(chain, fileChain);
      return true;
    }
    function mergeChain(target, source2) {
      target.options.push(...source2.options);
      target.plugins.push(...source2.plugins);
      target.presets.push(...source2.presets);
      for (const file of source2.files) {
        target.files.add(file);
      }
      return target;
    }
    function* mergeChainOpts(target, {
      options,
      plugins,
      presets
    }) {
      target.options.push(options);
      target.plugins.push(...yield* plugins());
      target.presets.push(...yield* presets());
      return target;
    }
    function emptyChain() {
      return {
        options: [],
        presets: [],
        plugins: [],
        files: /* @__PURE__ */ new Set()
      };
    }
    function normalizeOptions(opts) {
      const options = Object.assign({}, opts);
      delete options.extends;
      delete options.env;
      delete options.overrides;
      delete options.plugins;
      delete options.presets;
      delete options.passPerPreset;
      delete options.ignore;
      delete options.only;
      delete options.test;
      delete options.include;
      delete options.exclude;
      if (Object.prototype.hasOwnProperty.call(options, "sourceMap")) {
        options.sourceMaps = options.sourceMap;
        delete options.sourceMap;
      }
      return options;
    }
    function dedupDescriptors(items) {
      const map = /* @__PURE__ */ new Map();
      const descriptors = [];
      for (const item of items) {
        if (typeof item.value === "function") {
          const fnKey = item.value;
          let nameMap = map.get(fnKey);
          if (!nameMap) {
            nameMap = /* @__PURE__ */ new Map();
            map.set(fnKey, nameMap);
          }
          let desc = nameMap.get(item.name);
          if (!desc) {
            desc = {
              value: item
            };
            descriptors.push(desc);
            if (!item.ownPass)
              nameMap.set(item.name, desc);
          } else {
            desc.value = item;
          }
        } else {
          descriptors.push({
            value: item
          });
        }
      }
      return descriptors.reduce((acc, desc) => {
        acc.push(desc.value);
        return acc;
      }, []);
    }
    function configIsApplicable({
      options
    }, dirname, context, configName) {
      return (options.test === void 0 || configFieldIsApplicable(context, options.test, dirname, configName)) && (options.include === void 0 || configFieldIsApplicable(context, options.include, dirname, configName)) && (options.exclude === void 0 || !configFieldIsApplicable(context, options.exclude, dirname, configName));
    }
    function configFieldIsApplicable(context, test, dirname, configName) {
      const patterns = Array.isArray(test) ? test : [test];
      return matchesPatterns(context, patterns, dirname, configName);
    }
    function ignoreListReplacer(_key, value2) {
      if (value2 instanceof RegExp) {
        return String(value2);
      }
      return value2;
    }
    function shouldIgnore(context, ignore3, only, dirname) {
      if (ignore3 && matchesPatterns(context, ignore3, dirname)) {
        var _context$filename;
        const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore3, ignoreListReplacer)}\` from "${dirname}"`;
        debug(message);
        if (context.showConfig) {
          console.log(message);
        }
        return true;
      }
      if (only && !matchesPatterns(context, only, dirname)) {
        var _context$filename2;
        const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only, ignoreListReplacer)}\` from "${dirname}"`;
        debug(message);
        if (context.showConfig) {
          console.log(message);
        }
        return true;
      }
      return false;
    }
    function matchesPatterns(context, patterns, dirname, configName) {
      return patterns.some((pattern) => matchPattern(pattern, dirname, context.filename, context, configName));
    }
    function matchPattern(pattern, dirname, pathToTest, context, configName) {
      if (typeof pattern === "function") {
        return !!(0, _rewriteStackTrace.endHiddenCallStack)(pattern)(pathToTest, {
          dirname,
          envName: context.envName,
          caller: context.caller
        });
      }
      if (typeof pathToTest !== "string") {
        throw new _configError.default(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName);
      }
      if (typeof pattern === "string") {
        pattern = (0, _patternToRegex.default)(pattern, dirname);
      }
      return pattern.test(pathToTest);
    }
  }
});

// node_modules/@babel/core/lib/config/validation/plugins.js
var require_plugins3 = __commonJS({
  "node_modules/@babel/core/lib/config/validation/plugins.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.validatePluginObject = validatePluginObject;
    var _optionAssertions = require_option_assertions();
    var VALIDATORS = {
      name: _optionAssertions.assertString,
      manipulateOptions: _optionAssertions.assertFunction,
      pre: _optionAssertions.assertFunction,
      post: _optionAssertions.assertFunction,
      inherits: _optionAssertions.assertFunction,
      visitor: assertVisitorMap,
      parserOverride: _optionAssertions.assertFunction,
      generatorOverride: _optionAssertions.assertFunction
    };
    function assertVisitorMap(loc, value2) {
      const obj = (0, _optionAssertions.assertObject)(loc, value2);
      if (obj) {
        Object.keys(obj).forEach((prop) => assertVisitorHandler(prop, obj[prop]));
        if (obj.enter || obj.exit) {
          throw new Error(`${(0, _optionAssertions.msg)(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
        }
      }
      return obj;
    }
    function assertVisitorHandler(key2, value2) {
      if (value2 && typeof value2 === "object") {
        Object.keys(value2).forEach((handler) => {
          if (handler !== "enter" && handler !== "exit") {
            throw new Error(`.visitor["${key2}"] may only have .enter and/or .exit handlers.`);
          }
        });
      } else if (typeof value2 !== "function") {
        throw new Error(`.visitor["${key2}"] must be a function`);
      }
      return value2;
    }
    function validatePluginObject(obj) {
      const rootPath = {
        type: "root",
        source: "plugin"
      };
      Object.keys(obj).forEach((key2) => {
        const validator = VALIDATORS[key2];
        if (validator) {
          const optLoc = {
            type: "option",
            name: key2,
            parent: rootPath
          };
          validator(optLoc, obj[key2]);
        } else {
          const invalidPluginPropertyError = new Error(`.${key2} is not a valid Plugin property`);
          invalidPluginPropertyError.code = "BABEL_UNKNOWN_PLUGIN_PROPERTY";
          throw invalidPluginPropertyError;
        }
      });
      return obj;
    }
  }
});

// node_modules/@babel/core/lib/config/helpers/environment.js
var require_environment = __commonJS({
  "node_modules/@babel/core/lib/config/helpers/environment.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.getEnv = getEnv;
    function getEnv(defaultValue = "development") {
      return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
    }
  }
});

// node_modules/@babel/core/lib/config/partial.js
var require_partial = __commonJS({
  "node_modules/@babel/core/lib/config/partial.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = loadPrivatePartialConfig;
    exports.loadPartialConfig = void 0;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _plugin = require_plugin();
    var _util = require_util2();
    var _item = require_item();
    var _configChain = require_config_chain();
    var _environment = require_environment();
    var _options = require_options3();
    var _files = require_files();
    var _resolveTargets = require_resolve_targets();
    var _excluded = ["showIgnoredFiles"];
    function _objectWithoutPropertiesLoose(source2, excluded) {
      if (source2 == null)
        return {};
      var target = {};
      var sourceKeys = Object.keys(source2);
      var key2, i;
      for (i = 0; i < sourceKeys.length; i++) {
        key2 = sourceKeys[i];
        if (excluded.indexOf(key2) >= 0)
          continue;
        target[key2] = source2[key2];
      }
      return target;
    }
    function resolveRootMode(rootDir, rootMode) {
      switch (rootMode) {
        case "root":
          return rootDir;
        case "upward-optional": {
          const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
          return upwardRootDir === null ? rootDir : upwardRootDir;
        }
        case "upward": {
          const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
          if (upwardRootDir !== null)
            return upwardRootDir;
          throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not be found when searching upward from "${rootDir}".
One of the following config files must be in the directory tree: "${_files.ROOT_CONFIG_FILENAMES.join(", ")}".`), {
            code: "BABEL_ROOT_NOT_FOUND",
            dirname: rootDir
          });
        }
        default:
          throw new Error(`Assertion failure - unknown rootMode value.`);
      }
    }
    function* loadPrivatePartialConfig(inputOpts) {
      if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
        throw new Error("Babel options must be an object, null, or undefined");
      }
      const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
      const {
        envName = (0, _environment.getEnv)(),
        cwd = ".",
        root: rootDir = ".",
        rootMode = "root",
        caller,
        cloneInputAst = true
      } = args;
      const absoluteCwd = _path().resolve(cwd);
      const absoluteRootDir = resolveRootMode(_path().resolve(absoluteCwd, rootDir), rootMode);
      const filename = typeof args.filename === "string" ? _path().resolve(cwd, args.filename) : void 0;
      const showConfigPath = yield* (0, _files.resolveShowConfigPath)(absoluteCwd);
      const context = {
        filename,
        cwd: absoluteCwd,
        root: absoluteRootDir,
        envName,
        caller,
        showConfig: showConfigPath === filename
      };
      const configChain = yield* (0, _configChain.buildRootChain)(args, context);
      if (!configChain)
        return null;
      const merged = {
        assumptions: {}
      };
      configChain.options.forEach((opts) => {
        (0, _util.mergeOptions)(merged, opts);
      });
      const options = Object.assign({}, merged, {
        targets: (0, _resolveTargets.resolveTargets)(merged, absoluteRootDir),
        cloneInputAst,
        babelrc: false,
        configFile: false,
        browserslistConfigFile: false,
        passPerPreset: false,
        envName: context.envName,
        cwd: context.cwd,
        root: context.root,
        rootMode: "root",
        filename: typeof context.filename === "string" ? context.filename : void 0,
        plugins: configChain.plugins.map((descriptor) => (0, _item.createItemFromDescriptor)(descriptor)),
        presets: configChain.presets.map((descriptor) => (0, _item.createItemFromDescriptor)(descriptor))
      });
      return {
        options,
        context,
        fileHandling: configChain.fileHandling,
        ignore: configChain.ignore,
        babelrc: configChain.babelrc,
        config: configChain.config,
        files: configChain.files
      };
    }
    var loadPartialConfig = _gensync()(function* (opts) {
      let showIgnoredFiles = false;
      if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
        var _opts = opts;
        ({
          showIgnoredFiles
        } = _opts);
        opts = _objectWithoutPropertiesLoose(_opts, _excluded);
        _opts;
      }
      const result = yield* loadPrivatePartialConfig(opts);
      if (!result)
        return null;
      const {
        options,
        babelrc,
        ignore: ignore3,
        config,
        fileHandling,
        files
      } = result;
      if (fileHandling === "ignored" && !showIgnoredFiles) {
        return null;
      }
      (options.plugins || []).forEach((item) => {
        if (item.value instanceof _plugin.default) {
          throw new Error("Passing cached plugin instances is not supported in babel.loadPartialConfig()");
        }
      });
      return new PartialConfig(options, babelrc ? babelrc.filepath : void 0, ignore3 ? ignore3.filepath : void 0, config ? config.filepath : void 0, fileHandling, files);
    });
    exports.loadPartialConfig = loadPartialConfig;
    var PartialConfig = class {
      constructor(options, babelrc, ignore3, config, fileHandling, files) {
        this.options = void 0;
        this.babelrc = void 0;
        this.babelignore = void 0;
        this.config = void 0;
        this.fileHandling = void 0;
        this.files = void 0;
        this.options = options;
        this.babelignore = ignore3;
        this.babelrc = babelrc;
        this.config = config;
        this.fileHandling = fileHandling;
        this.files = files;
        Object.freeze(this);
      }
      hasFilesystemConfig() {
        return this.babelrc !== void 0 || this.config !== void 0;
      }
    };
    Object.freeze(PartialConfig.prototype);
  }
});

// node_modules/@babel/core/lib/config/full.js
var require_full = __commonJS({
  "node_modules/@babel/core/lib/config/full.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _async = require_async();
    var _util = require_util2();
    var context = require_lib32();
    var _plugin = require_plugin();
    var _item = require_item();
    var _configChain = require_config_chain();
    var _deepArray = require_deep_array();
    function _traverse() {
      const data3 = require_lib13();
      _traverse = function() {
        return data3;
      };
      return data3;
    }
    var _caching = require_caching();
    var _options = require_options3();
    var _plugins = require_plugins3();
    var _configApi = require_config_api();
    var _partial = require_partial();
    var _configError = require_config_error();
    var _default = _gensync()(function* loadFullConfig(inputOpts) {
      var _opts$assumptions;
      const result = yield* (0, _partial.default)(inputOpts);
      if (!result) {
        return null;
      }
      const {
        options,
        context: context2,
        fileHandling
      } = result;
      if (fileHandling === "ignored") {
        return null;
      }
      const optionDefaults = {};
      const {
        plugins,
        presets
      } = options;
      if (!plugins || !presets) {
        throw new Error("Assertion failure - plugins and presets exist");
      }
      const presetContext = Object.assign({}, context2, {
        targets: options.targets
      });
      const toDescriptor = (item) => {
        const desc = (0, _item.getItemDescriptor)(item);
        if (!desc) {
          throw new Error("Assertion failure - must be config item");
        }
        return desc;
      };
      const presetsDescriptors = presets.map(toDescriptor);
      const initialPluginsDescriptors = plugins.map(toDescriptor);
      const pluginDescriptorsByPass = [[]];
      const passes = [];
      const externalDependencies = [];
      const ignored = yield* enhanceError(context2, function* recursePresetDescriptors(rawPresets, pluginDescriptorsPass) {
        const presets2 = [];
        for (let i = 0; i < rawPresets.length; i++) {
          const descriptor = rawPresets[i];
          if (descriptor.options !== false) {
            try {
              var preset = yield* loadPresetDescriptor(descriptor, presetContext);
            } catch (e) {
              if (e.code === "BABEL_UNKNOWN_OPTION") {
                (0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e);
              }
              throw e;
            }
            externalDependencies.push(preset.externalDependencies);
            if (descriptor.ownPass) {
              presets2.push({
                preset: preset.chain,
                pass: []
              });
            } else {
              presets2.unshift({
                preset: preset.chain,
                pass: pluginDescriptorsPass
              });
            }
          }
        }
        if (presets2.length > 0) {
          pluginDescriptorsByPass.splice(1, 0, ...presets2.map((o) => o.pass).filter((p) => p !== pluginDescriptorsPass));
          for (const {
            preset: preset2,
            pass
          } of presets2) {
            if (!preset2)
              return true;
            pass.push(...preset2.plugins);
            const ignored2 = yield* recursePresetDescriptors(preset2.presets, pass);
            if (ignored2)
              return true;
            preset2.options.forEach((opts2) => {
              (0, _util.mergeOptions)(optionDefaults, opts2);
            });
          }
        }
      })(presetsDescriptors, pluginDescriptorsByPass[0]);
      if (ignored)
        return null;
      const opts = optionDefaults;
      (0, _util.mergeOptions)(opts, options);
      const pluginContext = Object.assign({}, presetContext, {
        assumptions: (_opts$assumptions = opts.assumptions) != null ? _opts$assumptions : {}
      });
      yield* enhanceError(context2, function* loadPluginDescriptors() {
        pluginDescriptorsByPass[0].unshift(...initialPluginsDescriptors);
        for (const descs of pluginDescriptorsByPass) {
          const pass = [];
          passes.push(pass);
          for (let i = 0; i < descs.length; i++) {
            const descriptor = descs[i];
            if (descriptor.options !== false) {
              try {
                var plugin2 = yield* loadPluginDescriptor(descriptor, pluginContext);
              } catch (e) {
                if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") {
                  (0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e);
                }
                throw e;
              }
              pass.push(plugin2);
              externalDependencies.push(plugin2.externalDependencies);
            }
          }
        }
      })();
      opts.plugins = passes[0];
      opts.presets = passes.slice(1).filter((plugins2) => plugins2.length > 0).map((plugins2) => ({
        plugins: plugins2
      }));
      opts.passPerPreset = opts.presets.length > 0;
      return {
        options: opts,
        passes,
        externalDependencies: (0, _deepArray.finalize)(externalDependencies)
      };
    });
    exports.default = _default;
    function enhanceError(context2, fn) {
      return function* (arg1, arg2) {
        try {
          return yield* fn(arg1, arg2);
        } catch (e) {
          if (!/^\[BABEL\]/.test(e.message)) {
            var _context$filename;
            e.message = `[BABEL] ${(_context$filename = context2.filename) != null ? _context$filename : "unknown file"}: ${e.message}`;
          }
          throw e;
        }
      };
    }
    var makeDescriptorLoader = (apiFactory) => (0, _caching.makeWeakCache)(function* ({
      value: value2,
      options,
      dirname,
      alias
    }, cache) {
      if (options === false)
        throw new Error("Assertion failure");
      options = options || {};
      const externalDependencies = [];
      let item = value2;
      if (typeof value2 === "function") {
        const factory = (0, _async.maybeAsync)(value2, `You appear to be using an async plugin/preset, but Babel has been called synchronously`);
        const api = Object.assign({}, context, apiFactory(cache, externalDependencies));
        try {
          item = yield* factory(api, options, dirname);
        } catch (e) {
          if (alias) {
            e.message += ` (While processing: ${JSON.stringify(alias)})`;
          }
          throw e;
        }
      }
      if (!item || typeof item !== "object") {
        throw new Error("Plugin/Preset did not return an object.");
      }
      if ((0, _async.isThenable)(item)) {
        yield* [];
        throw new Error(`You appear to be using a promise as a plugin, which your current version of Babel does not support. If you're using a published plugin, you may need to upgrade your @babel/core version. As an alternative, you can prefix the promise with "await". (While processing: ${JSON.stringify(alias)})`);
      }
      if (externalDependencies.length > 0 && (!cache.configured() || cache.mode() === "forever")) {
        let error = `A plugin/preset has external untracked dependencies (${externalDependencies[0]}), but the cache `;
        if (!cache.configured()) {
          error += `has not been configured to be invalidated when the external dependencies change. `;
        } else {
          error += ` has been configured to never be invalidated. `;
        }
        error += `Plugins/presets should configure their cache to be invalidated when the external dependencies change, for example using \`api.cache.invalidate(() => statSync(filepath).mtimeMs)\` or \`api.cache.never()\`
(While processing: ${JSON.stringify(alias)})`;
        throw new Error(error);
      }
      return {
        value: item,
        options,
        dirname,
        alias,
        externalDependencies: (0, _deepArray.finalize)(externalDependencies)
      };
    });
    var pluginDescriptorLoader = makeDescriptorLoader(_configApi.makePluginAPI);
    var presetDescriptorLoader = makeDescriptorLoader(_configApi.makePresetAPI);
    var instantiatePlugin = (0, _caching.makeWeakCache)(function* ({
      value: value2,
      options,
      dirname,
      alias,
      externalDependencies
    }, cache) {
      const pluginObj = (0, _plugins.validatePluginObject)(value2);
      const plugin2 = Object.assign({}, pluginObj);
      if (plugin2.visitor) {
        plugin2.visitor = _traverse().default.explode(Object.assign({}, plugin2.visitor));
      }
      if (plugin2.inherits) {
        const inheritsDescriptor = {
          name: void 0,
          alias: `${alias}$inherits`,
          value: plugin2.inherits,
          options,
          dirname
        };
        const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, (run) => {
          return cache.invalidate((data3) => run(inheritsDescriptor, data3));
        });
        plugin2.pre = chain(inherits.pre, plugin2.pre);
        plugin2.post = chain(inherits.post, plugin2.post);
        plugin2.manipulateOptions = chain(inherits.manipulateOptions, plugin2.manipulateOptions);
        plugin2.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin2.visitor || {}]);
        if (inherits.externalDependencies.length > 0) {
          if (externalDependencies.length === 0) {
            externalDependencies = inherits.externalDependencies;
          } else {
            externalDependencies = (0, _deepArray.finalize)([externalDependencies, inherits.externalDependencies]);
          }
        }
      }
      return new _plugin.default(plugin2, options, alias, externalDependencies);
    });
    function* loadPluginDescriptor(descriptor, context2) {
      if (descriptor.value instanceof _plugin.default) {
        if (descriptor.options) {
          throw new Error("Passed options to an existing Plugin instance will not work.");
        }
        return descriptor.value;
      }
      return yield* instantiatePlugin(yield* pluginDescriptorLoader(descriptor, context2), context2);
    }
    var needsFilename = (val) => val && typeof val !== "function";
    var validateIfOptionNeedsFilename = (options, descriptor) => {
      if (needsFilename(options.test) || needsFilename(options.include) || needsFilename(options.exclude)) {
        const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */";
        throw new _configError.default([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transformSync(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n"));
      }
    };
    var validatePreset = (preset, context2, descriptor) => {
      if (!context2.filename) {
        const {
          options
        } = preset;
        validateIfOptionNeedsFilename(options, descriptor);
        if (options.overrides) {
          options.overrides.forEach((overrideOptions) => validateIfOptionNeedsFilename(overrideOptions, descriptor));
        }
      }
    };
    var instantiatePreset = (0, _caching.makeWeakCacheSync)(({
      value: value2,
      dirname,
      alias,
      externalDependencies
    }) => {
      return {
        options: (0, _options.validate)("preset", value2),
        alias,
        dirname,
        externalDependencies
      };
    });
    function* loadPresetDescriptor(descriptor, context2) {
      const preset = instantiatePreset(yield* presetDescriptorLoader(descriptor, context2));
      validatePreset(preset, context2, descriptor);
      return {
        chain: yield* (0, _configChain.buildPresetChain)(preset, context2),
        externalDependencies: preset.externalDependencies
      };
    }
    function chain(a, b) {
      const fns = [a, b].filter(Boolean);
      if (fns.length <= 1)
        return fns[0];
      return function(...args) {
        for (const fn of fns) {
          fn.apply(this, args);
        }
      };
    }
  }
});

// node_modules/@babel/core/lib/config/index.js
var require_config = __commonJS({
  "node_modules/@babel/core/lib/config/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.createConfigItem = createConfigItem;
    exports.createConfigItemSync = exports.createConfigItemAsync = void 0;
    Object.defineProperty(exports, "default", {
      enumerable: true,
      get: function() {
        return _full.default;
      }
    });
    exports.loadPartialConfigSync = exports.loadPartialConfigAsync = exports.loadPartialConfig = exports.loadOptionsSync = exports.loadOptionsAsync = exports.loadOptions = void 0;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _full = require_full();
    var _partial = require_partial();
    var _item = require_item();
    var loadOptionsRunner = _gensync()(function* (opts) {
      var _config$options;
      const config = yield* (0, _full.default)(opts);
      return (_config$options = config == null ? void 0 : config.options) != null ? _config$options : null;
    });
    var createConfigItemRunner = _gensync()(_item.createConfigItem);
    var maybeErrback = (runner) => (argOrCallback, maybeCallback) => {
      let arg;
      let callback;
      if (maybeCallback === void 0 && typeof argOrCallback === "function") {
        callback = argOrCallback;
        arg = void 0;
      } else {
        callback = maybeCallback;
        arg = argOrCallback;
      }
      if (!callback) {
        return runner.sync(arg);
      }
      runner.errback(arg, callback);
    };
    var loadPartialConfig = maybeErrback(_partial.loadPartialConfig);
    exports.loadPartialConfig = loadPartialConfig;
    var loadPartialConfigSync = _partial.loadPartialConfig.sync;
    exports.loadPartialConfigSync = loadPartialConfigSync;
    var loadPartialConfigAsync = _partial.loadPartialConfig.async;
    exports.loadPartialConfigAsync = loadPartialConfigAsync;
    var loadOptions = maybeErrback(loadOptionsRunner);
    exports.loadOptions = loadOptions;
    var loadOptionsSync = loadOptionsRunner.sync;
    exports.loadOptionsSync = loadOptionsSync;
    var loadOptionsAsync = loadOptionsRunner.async;
    exports.loadOptionsAsync = loadOptionsAsync;
    var createConfigItemSync = createConfigItemRunner.sync;
    exports.createConfigItemSync = createConfigItemSync;
    var createConfigItemAsync = createConfigItemRunner.async;
    exports.createConfigItemAsync = createConfigItemAsync;
    function createConfigItem(target, options, callback) {
      if (callback !== void 0) {
        createConfigItemRunner.errback(target, options, callback);
      } else if (typeof options === "function") {
        createConfigItemRunner.errback(target, void 0, callback);
      } else {
        return createConfigItemRunner.sync(target, options);
      }
    }
  }
});

// node_modules/@babel/core/lib/transformation/plugin-pass.js
var require_plugin_pass = __commonJS({
  "node_modules/@babel/core/lib/transformation/plugin-pass.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var PluginPass = class {
      constructor(file, key2, options) {
        this._map = /* @__PURE__ */ new Map();
        this.key = void 0;
        this.file = void 0;
        this.opts = void 0;
        this.cwd = void 0;
        this.filename = void 0;
        this.key = key2;
        this.file = file;
        this.opts = options || {};
        this.cwd = file.opts.cwd;
        this.filename = file.opts.filename;
      }
      set(key2, val) {
        this._map.set(key2, val);
      }
      get(key2) {
        return this._map.get(key2);
      }
      availableHelper(name2, versionRange) {
        return this.file.availableHelper(name2, versionRange);
      }
      addHelper(name2) {
        return this.file.addHelper(name2);
      }
      addImport() {
        this.file.addImport();
      }
      buildCodeFrameError(node2, msg, _Error) {
        return this.file.buildCodeFrameError(node2, msg, _Error);
      }
    };
    exports.default = PluginPass;
    {
      PluginPass.prototype.getModuleName = function getModuleName() {
        return this.file.getModuleName();
      };
    }
  }
});

// node_modules/@babel/core/lib/transformation/block-hoist-plugin.js
var require_block_hoist_plugin = __commonJS({
  "node_modules/@babel/core/lib/transformation/block-hoist-plugin.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = loadBlockHoistPlugin;
    function _traverse() {
      const data3 = require_lib13();
      _traverse = function() {
        return data3;
      };
      return data3;
    }
    var _plugin = require_plugin();
    var LOADED_PLUGIN;
    var blockHoistPlugin = {
      name: "internal.blockHoist",
      visitor: {
        Block: {
          exit({
            node: node2
          }) {
            const {
              body
            } = node2;
            let max = Math.pow(2, 30) - 1;
            let hasChange = false;
            for (let i = 0; i < body.length; i++) {
              const n = body[i];
              const p = priority(n);
              if (p > max) {
                hasChange = true;
                break;
              }
              max = p;
            }
            if (!hasChange)
              return;
            node2.body = stableSort(body.slice());
          }
        }
      }
    };
    function loadBlockHoistPlugin() {
      if (!LOADED_PLUGIN) {
        LOADED_PLUGIN = new _plugin.default(Object.assign({}, blockHoistPlugin, {
          visitor: _traverse().default.explode(blockHoistPlugin.visitor)
        }), {});
      }
      return LOADED_PLUGIN;
    }
    function priority(bodyNode) {
      const priority2 = bodyNode == null ? void 0 : bodyNode._blockHoist;
      if (priority2 == null)
        return 1;
      if (priority2 === true)
        return 2;
      return priority2;
    }
    function stableSort(body) {
      const buckets = /* @__PURE__ */ Object.create(null);
      for (let i = 0; i < body.length; i++) {
        const n = body[i];
        const p = priority(n);
        const bucket = buckets[p] || (buckets[p] = []);
        bucket.push(n);
      }
      const keys2 = Object.keys(buckets).map((k) => +k).sort((a, b) => b - a);
      let index2 = 0;
      for (const key2 of keys2) {
        const bucket = buckets[key2];
        for (const n of bucket) {
          body[index2++] = n;
        }
      }
      return body;
    }
  }
});

// node_modules/@babel/core/lib/transformation/normalize-opts.js
var require_normalize_opts = __commonJS({
  "node_modules/@babel/core/lib/transformation/normalize-opts.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = normalizeOptions;
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function normalizeOptions(config) {
      const {
        filename,
        cwd,
        filenameRelative = typeof filename === "string" ? _path().relative(cwd, filename) : "unknown",
        sourceType = "module",
        inputSourceMap,
        sourceMaps = !!inputSourceMap,
        sourceRoot = config.options.moduleRoot,
        sourceFileName = _path().basename(filenameRelative),
        comments = true,
        compact = "auto"
      } = config.options;
      const opts = config.options;
      const options = Object.assign({}, opts, {
        parserOpts: Object.assign({
          sourceType: _path().extname(filenameRelative) === ".mjs" ? "module" : sourceType,
          sourceFileName: filename,
          plugins: []
        }, opts.parserOpts),
        generatorOpts: Object.assign({
          filename,
          auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
          auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
          retainLines: opts.retainLines,
          comments,
          shouldPrintComment: opts.shouldPrintComment,
          compact,
          minified: opts.minified,
          sourceMaps,
          sourceRoot,
          sourceFileName
        }, opts.generatorOpts)
      });
      for (const plugins of config.passes) {
        for (const plugin2 of plugins) {
          if (plugin2.manipulateOptions) {
            plugin2.manipulateOptions(options, options.parserOpts);
          }
        }
      }
      return options;
    }
  }
});

// node_modules/convert-source-map/index.js
var require_convert_source_map = __commonJS({
  "node_modules/convert-source-map/index.js"(exports) {
    "use strict";
    var fs = require("fs");
    var path = require("path");
    Object.defineProperty(exports, "commentRegex", {
      get: function getCommentRegex() {
        return /^\s*\/(?:\/|\*)[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/mg;
      }
    });
    Object.defineProperty(exports, "mapFileCommentRegex", {
      get: function getMapFileCommentRegex() {
        return /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"`]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^\*]+?)[ \t]*(?:\*\/){1}[ \t]*$)/mg;
      }
    });
    var decodeBase64;
    if (typeof Buffer !== "undefined") {
      if (typeof Buffer.from === "function") {
        decodeBase64 = decodeBase64WithBufferFrom;
      } else {
        decodeBase64 = decodeBase64WithNewBuffer;
      }
    } else {
      decodeBase64 = decodeBase64WithAtob;
    }
    function decodeBase64WithBufferFrom(base64) {
      return Buffer.from(base64, "base64").toString();
    }
    function decodeBase64WithNewBuffer(base64) {
      if (typeof value === "number") {
        throw new TypeError("The value to decode must not be of type number.");
      }
      return new Buffer(base64, "base64").toString();
    }
    function decodeBase64WithAtob(base64) {
      return decodeURIComponent(escape(atob(base64)));
    }
    function stripComment(sm) {
      return sm.split(",").pop();
    }
    function readFromFileMap(sm, dir) {
      var r = exports.mapFileCommentRegex.exec(sm);
      var filename = r[1] || r[2];
      var filepath = path.resolve(dir, filename);
      try {
        return fs.readFileSync(filepath, "utf8");
      } catch (e) {
        throw new Error("An error occurred while trying to read the map file at " + filepath + "\n" + e);
      }
    }
    function Converter(sm, opts) {
      opts = opts || {};
      if (opts.isFileComment)
        sm = readFromFileMap(sm, opts.commentFileDir);
      if (opts.hasComment)
        sm = stripComment(sm);
      if (opts.isEncoded)
        sm = decodeBase64(sm);
      if (opts.isJSON || opts.isEncoded)
        sm = JSON.parse(sm);
      this.sourcemap = sm;
    }
    Converter.prototype.toJSON = function(space2) {
      return JSON.stringify(this.sourcemap, null, space2);
    };
    if (typeof Buffer !== "undefined") {
      if (typeof Buffer.from === "function") {
        Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
      } else {
        Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
      }
    } else {
      Converter.prototype.toBase64 = encodeBase64WithBtoa;
    }
    function encodeBase64WithBufferFrom() {
      var json = this.toJSON();
      return Buffer.from(json, "utf8").toString("base64");
    }
    function encodeBase64WithNewBuffer() {
      var json = this.toJSON();
      if (typeof json === "number") {
        throw new TypeError("The json to encode must not be of type number.");
      }
      return new Buffer(json, "utf8").toString("base64");
    }
    function encodeBase64WithBtoa() {
      var json = this.toJSON();
      return btoa(unescape(encodeURIComponent(json)));
    }
    Converter.prototype.toComment = function(options) {
      var base64 = this.toBase64();
      var data3 = "sourceMappingURL=data:application/json;charset=utf-8;base64," + base64;
      return options && options.multiline ? "/*# " + data3 + " */" : "//# " + data3;
    };
    Converter.prototype.toObject = function() {
      return JSON.parse(this.toJSON());
    };
    Converter.prototype.addProperty = function(key2, value2) {
      if (this.sourcemap.hasOwnProperty(key2))
        throw new Error('property "' + key2 + '" already exists on the sourcemap, use set property instead');
      return this.setProperty(key2, value2);
    };
    Converter.prototype.setProperty = function(key2, value2) {
      this.sourcemap[key2] = value2;
      return this;
    };
    Converter.prototype.getProperty = function(key2) {
      return this.sourcemap[key2];
    };
    exports.fromObject = function(obj) {
      return new Converter(obj);
    };
    exports.fromJSON = function(json) {
      return new Converter(json, { isJSON: true });
    };
    exports.fromBase64 = function(base64) {
      return new Converter(base64, { isEncoded: true });
    };
    exports.fromComment = function(comment2) {
      comment2 = comment2.replace(/^\/\*/g, "//").replace(/\*\/$/g, "");
      return new Converter(comment2, { isEncoded: true, hasComment: true });
    };
    exports.fromMapFileComment = function(comment2, dir) {
      return new Converter(comment2, { commentFileDir: dir, isFileComment: true, isJSON: true });
    };
    exports.fromSource = function(content3) {
      var m = content3.match(exports.commentRegex);
      return m ? exports.fromComment(m.pop()) : null;
    };
    exports.fromMapFileSource = function(content3, dir) {
      var m = content3.match(exports.mapFileCommentRegex);
      return m ? exports.fromMapFileComment(m.pop(), dir) : null;
    };
    exports.removeComments = function(src) {
      return src.replace(exports.commentRegex, "");
    };
    exports.removeMapFileComments = function(src) {
      return src.replace(exports.mapFileCommentRegex, "");
    };
    exports.generateMapFileComment = function(file, options) {
      var data3 = "sourceMappingURL=" + file;
      return options && options.multiline ? "/*# " + data3 + " */" : "//# " + data3;
    };
  }
});

// node_modules/@babel/core/lib/parser/util/missing-plugin-helper.js
var require_missing_plugin_helper = __commonJS({
  "node_modules/@babel/core/lib/parser/util/missing-plugin-helper.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = generateMissingPluginMessage;
    var pluginNameMap = {
      asyncDoExpressions: {
        syntax: {
          name: "@babel/plugin-syntax-async-do-expressions",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-async-do-expressions"
        }
      },
      decimal: {
        syntax: {
          name: "@babel/plugin-syntax-decimal",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-decimal"
        }
      },
      decorators: {
        syntax: {
          name: "@babel/plugin-syntax-decorators",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-decorators"
        },
        transform: {
          name: "@babel/plugin-proposal-decorators",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-decorators"
        }
      },
      doExpressions: {
        syntax: {
          name: "@babel/plugin-syntax-do-expressions",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-do-expressions"
        },
        transform: {
          name: "@babel/plugin-proposal-do-expressions",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-do-expressions"
        }
      },
      exportDefaultFrom: {
        syntax: {
          name: "@babel/plugin-syntax-export-default-from",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-export-default-from"
        },
        transform: {
          name: "@babel/plugin-proposal-export-default-from",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-export-default-from"
        }
      },
      flow: {
        syntax: {
          name: "@babel/plugin-syntax-flow",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-flow"
        },
        transform: {
          name: "@babel/preset-flow",
          url: "https://github.com/babel/babel/tree/main/packages/babel-preset-flow"
        }
      },
      functionBind: {
        syntax: {
          name: "@babel/plugin-syntax-function-bind",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-function-bind"
        },
        transform: {
          name: "@babel/plugin-proposal-function-bind",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-function-bind"
        }
      },
      functionSent: {
        syntax: {
          name: "@babel/plugin-syntax-function-sent",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-function-sent"
        },
        transform: {
          name: "@babel/plugin-proposal-function-sent",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-function-sent"
        }
      },
      jsx: {
        syntax: {
          name: "@babel/plugin-syntax-jsx",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-jsx"
        },
        transform: {
          name: "@babel/preset-react",
          url: "https://github.com/babel/babel/tree/main/packages/babel-preset-react"
        }
      },
      importAssertions: {
        syntax: {
          name: "@babel/plugin-syntax-import-assertions",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-import-assertions"
        }
      },
      pipelineOperator: {
        syntax: {
          name: "@babel/plugin-syntax-pipeline-operator",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-pipeline-operator"
        },
        transform: {
          name: "@babel/plugin-proposal-pipeline-operator",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-pipeline-operator"
        }
      },
      recordAndTuple: {
        syntax: {
          name: "@babel/plugin-syntax-record-and-tuple",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-record-and-tuple"
        }
      },
      regexpUnicodeSets: {
        syntax: {
          name: "@babel/plugin-syntax-unicode-sets-regex",
          url: "https://github.com/babel/babel/blob/main/packages/babel-plugin-syntax-unicode-sets-regex/README.md"
        },
        transform: {
          name: "@babel/plugin-proposal-unicode-sets-regex",
          url: "https://github.com/babel/babel/blob/main/packages/babel-plugin-proposalunicode-sets-regex/README.md"
        }
      },
      throwExpressions: {
        syntax: {
          name: "@babel/plugin-syntax-throw-expressions",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-throw-expressions"
        },
        transform: {
          name: "@babel/plugin-proposal-throw-expressions",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-throw-expressions"
        }
      },
      typescript: {
        syntax: {
          name: "@babel/plugin-syntax-typescript",
          url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-typescript"
        },
        transform: {
          name: "@babel/preset-typescript",
          url: "https://github.com/babel/babel/tree/main/packages/babel-preset-typescript"
        }
      }
    };
    {
      Object.assign(pluginNameMap, {
        asyncGenerators: {
          syntax: {
            name: "@babel/plugin-syntax-async-generators",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-async-generators"
          },
          transform: {
            name: "@babel/plugin-proposal-async-generator-functions",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-async-generator-functions"
          }
        },
        classProperties: {
          syntax: {
            name: "@babel/plugin-syntax-class-properties",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-class-properties"
          },
          transform: {
            name: "@babel/plugin-proposal-class-properties",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-class-properties"
          }
        },
        classPrivateProperties: {
          syntax: {
            name: "@babel/plugin-syntax-class-properties",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-class-properties"
          },
          transform: {
            name: "@babel/plugin-proposal-class-properties",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-class-properties"
          }
        },
        classPrivateMethods: {
          syntax: {
            name: "@babel/plugin-syntax-class-properties",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-class-properties"
          },
          transform: {
            name: "@babel/plugin-proposal-private-methods",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-private-methods"
          }
        },
        classStaticBlock: {
          syntax: {
            name: "@babel/plugin-syntax-class-static-block",
            url: "https://github.com/babel/babel/tree/HEAD/packages/babel-plugin-syntax-class-static-block"
          },
          transform: {
            name: "@babel/plugin-proposal-class-static-block",
            url: "https://github.com/babel/babel/tree/HEAD/packages/babel-plugin-proposal-class-static-block"
          }
        },
        dynamicImport: {
          syntax: {
            name: "@babel/plugin-syntax-dynamic-import",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-dynamic-import"
          }
        },
        exportNamespaceFrom: {
          syntax: {
            name: "@babel/plugin-syntax-export-namespace-from",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-export-namespace-from"
          },
          transform: {
            name: "@babel/plugin-proposal-export-namespace-from",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-export-namespace-from"
          }
        },
        importMeta: {
          syntax: {
            name: "@babel/plugin-syntax-import-meta",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-import-meta"
          }
        },
        logicalAssignment: {
          syntax: {
            name: "@babel/plugin-syntax-logical-assignment-operators",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-logical-assignment-operators"
          },
          transform: {
            name: "@babel/plugin-proposal-logical-assignment-operators",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-logical-assignment-operators"
          }
        },
        moduleStringNames: {
          syntax: {
            name: "@babel/plugin-syntax-module-string-names",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-module-string-names"
          }
        },
        numericSeparator: {
          syntax: {
            name: "@babel/plugin-syntax-numeric-separator",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-numeric-separator"
          },
          transform: {
            name: "@babel/plugin-proposal-numeric-separator",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-numeric-separator"
          }
        },
        nullishCoalescingOperator: {
          syntax: {
            name: "@babel/plugin-syntax-nullish-coalescing-operator",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-nullish-coalescing-operator"
          },
          transform: {
            name: "@babel/plugin-proposal-nullish-coalescing-operator",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-transform-nullish-coalescing-opearator"
          }
        },
        objectRestSpread: {
          syntax: {
            name: "@babel/plugin-syntax-object-rest-spread",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-object-rest-spread"
          },
          transform: {
            name: "@babel/plugin-proposal-object-rest-spread",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-object-rest-spread"
          }
        },
        optionalCatchBinding: {
          syntax: {
            name: "@babel/plugin-syntax-optional-catch-binding",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-optional-catch-binding"
          },
          transform: {
            name: "@babel/plugin-proposal-optional-catch-binding",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-optional-catch-binding"
          }
        },
        optionalChaining: {
          syntax: {
            name: "@babel/plugin-syntax-optional-chaining",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-optional-chaining"
          },
          transform: {
            name: "@babel/plugin-proposal-optional-chaining",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-optional-chaining"
          }
        },
        privateIn: {
          syntax: {
            name: "@babel/plugin-syntax-private-property-in-object",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-syntax-private-property-in-object"
          },
          transform: {
            name: "@babel/plugin-proposal-private-property-in-object",
            url: "https://github.com/babel/babel/tree/main/packages/babel-plugin-proposal-private-property-in-object"
          }
        }
      });
    }
    var getNameURLCombination = ({
      name: name2,
      url
    }) => `${name2} (${url})`;
    function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
      let helpMessage = `Support for the experimental syntax '${missingPluginName}' isn't currently enabled (${loc.line}:${loc.column + 1}):

` + codeFrame;
      const pluginInfo = pluginNameMap[missingPluginName];
      if (pluginInfo) {
        const {
          syntax: syntaxPlugin,
          transform: transformPlugin
        } = pluginInfo;
        if (syntaxPlugin) {
          const syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
          if (transformPlugin) {
            const transformPluginInfo = getNameURLCombination(transformPlugin);
            const sectionType = transformPlugin.name.startsWith("@babel/plugin") ? "plugins" : "presets";
            helpMessage += `

Add ${transformPluginInfo} to the '${sectionType}' section of your Babel config to enable transformation.
If you want to leave it as-is, add ${syntaxPluginInfo} to the 'plugins' section to enable parsing.`;
          } else {
            helpMessage += `

Add ${syntaxPluginInfo} to the 'plugins' section of your Babel config to enable parsing.`;
          }
        }
      }
      return helpMessage;
    }
  }
});

// node_modules/@babel/core/lib/parser/index.js
var require_parser = __commonJS({
  "node_modules/@babel/core/lib/parser/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = parser;
    function _parser() {
      const data3 = require_lib9();
      _parser = function() {
        return data3;
      };
      return data3;
    }
    function _codeFrame() {
      const data3 = require_lib8();
      _codeFrame = function() {
        return data3;
      };
      return data3;
    }
    var _missingPluginHelper = require_missing_plugin_helper();
    function* parser(pluginPasses, {
      parserOpts,
      highlightCode = true,
      filename = "unknown"
    }, code2) {
      try {
        const results = [];
        for (const plugins of pluginPasses) {
          for (const plugin2 of plugins) {
            const {
              parserOverride
            } = plugin2;
            if (parserOverride) {
              const ast = parserOverride(code2, parserOpts, _parser().parse);
              if (ast !== void 0)
                results.push(ast);
            }
          }
        }
        if (results.length === 0) {
          return (0, _parser().parse)(code2, parserOpts);
        } else if (results.length === 1) {
          yield* [];
          if (typeof results[0].then === "function") {
            throw new Error(`You appear to be using an async parser plugin, which your current version of Babel does not support. If you're using a published plugin, you may need to upgrade your @babel/core version.`);
          }
          return results[0];
        }
        throw new Error("More than one plugin attempted to override parsing.");
      } catch (err) {
        if (err.code === "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED") {
          err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module or sourceType:unambiguous in your Babel config for this file.";
        }
        const {
          loc,
          missingPlugin
        } = err;
        if (loc) {
          const codeFrame = (0, _codeFrame().codeFrameColumns)(code2, {
            start: {
              line: loc.line,
              column: loc.column + 1
            }
          }, {
            highlightCode
          });
          if (missingPlugin) {
            err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
          } else {
            err.message = `${filename}: ${err.message}

` + codeFrame;
          }
          err.code = "BABEL_PARSE_ERROR";
        }
        throw err;
      }
    }
  }
});

// node_modules/@babel/core/lib/transformation/util/clone-deep.js
var require_clone_deep = __commonJS({
  "node_modules/@babel/core/lib/transformation/util/clone-deep.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = _default;
    function deepClone(value2, cache) {
      if (value2 !== null) {
        if (cache.has(value2))
          return cache.get(value2);
        let cloned;
        if (Array.isArray(value2)) {
          cloned = new Array(value2.length);
          cache.set(value2, cloned);
          for (let i = 0; i < value2.length; i++) {
            cloned[i] = typeof value2[i] !== "object" ? value2[i] : deepClone(value2[i], cache);
          }
        } else {
          cloned = {};
          cache.set(value2, cloned);
          const keys2 = Object.keys(value2);
          for (let i = 0; i < keys2.length; i++) {
            const key2 = keys2[i];
            cloned[key2] = typeof value2[key2] !== "object" ? value2[key2] : deepClone(value2[key2], cache);
          }
        }
        return cloned;
      }
      return value2;
    }
    function _default(value2) {
      if (typeof value2 !== "object")
        return value2;
      return deepClone(value2, /* @__PURE__ */ new Map());
    }
  }
});

// node_modules/@babel/core/lib/transformation/normalize-file.js
var require_normalize_file = __commonJS({
  "node_modules/@babel/core/lib/transformation/normalize-file.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = normalizeFile;
    function _fs() {
      const data3 = require("fs");
      _fs = function() {
        return data3;
      };
      return data3;
    }
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _debug() {
      const data3 = require_src();
      _debug = function() {
        return data3;
      };
      return data3;
    }
    function _t() {
      const data3 = require_lib3();
      _t = function() {
        return data3;
      };
      return data3;
    }
    function _convertSourceMap() {
      const data3 = require_convert_source_map();
      _convertSourceMap = function() {
        return data3;
      };
      return data3;
    }
    var _file = require_file();
    var _parser = require_parser();
    var _cloneDeep = require_clone_deep();
    var {
      file,
      traverseFast
    } = _t();
    var debug = _debug()("babel:transform:file");
    var INLINE_SOURCEMAP_REGEX = /^[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/;
    var EXTERNAL_SOURCEMAP_REGEX = /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/;
    function* normalizeFile(pluginPasses, options, code2, ast) {
      code2 = `${code2 || ""}`;
      if (ast) {
        if (ast.type === "Program") {
          ast = file(ast, [], []);
        } else if (ast.type !== "File") {
          throw new Error("AST root must be a Program or File node");
        }
        if (options.cloneInputAst) {
          ast = (0, _cloneDeep.default)(ast);
        }
      } else {
        ast = yield* (0, _parser.default)(pluginPasses, options, code2);
      }
      let inputMap = null;
      if (options.inputSourceMap !== false) {
        if (typeof options.inputSourceMap === "object") {
          inputMap = _convertSourceMap().fromObject(options.inputSourceMap);
        }
        if (!inputMap) {
          const lastComment = extractComments(INLINE_SOURCEMAP_REGEX, ast);
          if (lastComment) {
            try {
              inputMap = _convertSourceMap().fromComment(lastComment);
            } catch (err) {
              debug("discarding unknown inline input sourcemap", err);
            }
          }
        }
        if (!inputMap) {
          const lastComment = extractComments(EXTERNAL_SOURCEMAP_REGEX, ast);
          if (typeof options.filename === "string" && lastComment) {
            try {
              const match = EXTERNAL_SOURCEMAP_REGEX.exec(lastComment);
              const inputMapContent = _fs().readFileSync(_path().resolve(_path().dirname(options.filename), match[1]), "utf8");
              inputMap = _convertSourceMap().fromJSON(inputMapContent);
            } catch (err) {
              debug("discarding unknown file input sourcemap", err);
            }
          } else if (lastComment) {
            debug("discarding un-loadable file input sourcemap");
          }
        }
      }
      return new _file.default(options, {
        code: code2,
        ast,
        inputMap
      });
    }
    function extractCommentsFromList(regex2, comments, lastComment) {
      if (comments) {
        comments = comments.filter(({
          value: value2
        }) => {
          if (regex2.test(value2)) {
            lastComment = value2;
            return false;
          }
          return true;
        });
      }
      return [comments, lastComment];
    }
    function extractComments(regex2, ast) {
      let lastComment = null;
      traverseFast(ast, (node2) => {
        [node2.leadingComments, lastComment] = extractCommentsFromList(regex2, node2.leadingComments, lastComment);
        [node2.innerComments, lastComment] = extractCommentsFromList(regex2, node2.innerComments, lastComment);
        [node2.trailingComments, lastComment] = extractCommentsFromList(regex2, node2.trailingComments, lastComment);
      });
      return lastComment;
    }
  }
});

// node_modules/@ampproject/remapping/dist/remapping.umd.js
var require_remapping_umd = __commonJS({
  "node_modules/@ampproject/remapping/dist/remapping.umd.js"(exports, module2) {
    (function(global2, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory(require_trace_mapping_umd(), require_gen_mapping_umd()) : typeof define === "function" && define.amd ? define(["@jridgewell/trace-mapping", "@jridgewell/gen-mapping"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.remapping = factory(global2.traceMapping, global2.genMapping));
    })(exports, function(traceMapping, genMapping) {
      "use strict";
      const SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null);
      const EMPTY_SOURCES = [];
      function SegmentObject(source2, line2, column2, name2, content3) {
        return { source: source2, line: line2, column: column2, name: name2, content: content3 };
      }
      function Source(map, sources, source2, content3) {
        return {
          map,
          sources,
          source: source2,
          content: content3
        };
      }
      function MapSource(map, sources) {
        return Source(map, sources, "", null);
      }
      function OriginalSource(source2, content3) {
        return Source(null, EMPTY_SOURCES, source2, content3);
      }
      function traceMappings(tree) {
        const gen = new genMapping.GenMapping({ file: tree.map.file });
        const { sources: rootSources, map } = tree;
        const rootNames = map.names;
        const rootMappings = traceMapping.decodedMappings(map);
        for (let i = 0; i < rootMappings.length; i++) {
          const segments = rootMappings[i];
          for (let j = 0; j < segments.length; j++) {
            const segment = segments[j];
            const genCol = segment[0];
            let traced = SOURCELESS_MAPPING;
            if (segment.length !== 1) {
              const source3 = rootSources[segment[1]];
              traced = originalPositionFor(source3, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : "");
              if (traced == null)
                continue;
            }
            const { column: column2, line: line2, name: name2, content: content3, source: source2 } = traced;
            genMapping.maybeAddSegment(gen, i, genCol, source2, line2, column2, name2);
            if (source2 && content3 != null)
              genMapping.setSourceContent(gen, source2, content3);
          }
        }
        return gen;
      }
      function originalPositionFor(source2, line2, column2, name2) {
        if (!source2.map) {
          return SegmentObject(source2.source, line2, column2, name2, source2.content);
        }
        const segment = traceMapping.traceSegment(source2.map, line2, column2);
        if (segment == null)
          return null;
        if (segment.length === 1)
          return SOURCELESS_MAPPING;
        return originalPositionFor(source2.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source2.map.names[segment[4]] : name2);
      }
      function asArray(value2) {
        if (Array.isArray(value2))
          return value2;
        return [value2];
      }
      function buildSourceMapTree(input, loader) {
        const maps = asArray(input).map((m) => new traceMapping.TraceMap(m, ""));
        const map = maps.pop();
        for (let i = 0; i < maps.length; i++) {
          if (maps[i].sources.length > 1) {
            throw new Error(`Transformation map ${i} must have exactly one source file.
Did you specify these with the most recent transformation maps first?`);
          }
        }
        let tree = build(map, loader, "", 0);
        for (let i = maps.length - 1; i >= 0; i--) {
          tree = MapSource(maps[i], [tree]);
        }
        return tree;
      }
      function build(map, loader, importer, importerDepth) {
        const { resolvedSources, sourcesContent } = map;
        const depth = importerDepth + 1;
        const children = resolvedSources.map((sourceFile, i) => {
          const ctx = {
            importer,
            depth,
            source: sourceFile || "",
            content: void 0
          };
          const sourceMap = loader(ctx.source, ctx);
          const { source: source2, content: content3 } = ctx;
          if (sourceMap)
            return build(new traceMapping.TraceMap(sourceMap, source2), loader, source2, depth);
          const sourceContent = content3 !== void 0 ? content3 : sourcesContent ? sourcesContent[i] : null;
          return OriginalSource(source2, sourceContent);
        });
        return MapSource(map, children);
      }
      class SourceMap {
        constructor(map, options) {
          const out = options.decodedMappings ? genMapping.toDecodedMap(map) : genMapping.toEncodedMap(map);
          this.version = out.version;
          this.file = out.file;
          this.mappings = out.mappings;
          this.names = out.names;
          this.sourceRoot = out.sourceRoot;
          this.sources = out.sources;
          if (!options.excludeContent) {
            this.sourcesContent = out.sourcesContent;
          }
        }
        toString() {
          return JSON.stringify(this);
        }
      }
      function remapping(input, loader, options) {
        const opts = typeof options === "object" ? options : { excludeContent: !!options, decodedMappings: false };
        const tree = buildSourceMapTree(input, loader);
        return new SourceMap(traceMappings(tree), opts);
      }
      return remapping;
    });
  }
});

// node_modules/@babel/core/lib/transformation/file/merge-map.js
var require_merge_map = __commonJS({
  "node_modules/@babel/core/lib/transformation/file/merge-map.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = mergeSourceMap;
    function _remapping() {
      const data3 = require_remapping_umd();
      _remapping = function() {
        return data3;
      };
      return data3;
    }
    function mergeSourceMap(inputMap, map, sourceFileName) {
      const source2 = sourceFileName.replace(/\\/g, "/");
      let found = false;
      const result = _remapping()(rootless(map), (s, ctx) => {
        if (s === source2 && !found) {
          found = true;
          ctx.source = "";
          return rootless(inputMap);
        }
        return null;
      });
      if (typeof inputMap.sourceRoot === "string") {
        result.sourceRoot = inputMap.sourceRoot;
      }
      return Object.assign({}, result);
    }
    function rootless(map) {
      return Object.assign({}, map, {
        sourceRoot: null
      });
    }
  }
});

// node_modules/@babel/core/lib/transformation/file/generate.js
var require_generate = __commonJS({
  "node_modules/@babel/core/lib/transformation/file/generate.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = generateCode;
    function _convertSourceMap() {
      const data3 = require_convert_source_map();
      _convertSourceMap = function() {
        return data3;
      };
      return data3;
    }
    function _generator() {
      const data3 = require_lib4();
      _generator = function() {
        return data3;
      };
      return data3;
    }
    var _mergeMap = require_merge_map();
    function generateCode(pluginPasses, file) {
      const {
        opts,
        ast,
        code: code2,
        inputMap
      } = file;
      const {
        generatorOpts
      } = opts;
      generatorOpts.inputSourceMap = inputMap == null ? void 0 : inputMap.toObject();
      const results = [];
      for (const plugins of pluginPasses) {
        for (const plugin2 of plugins) {
          const {
            generatorOverride
          } = plugin2;
          if (generatorOverride) {
            const result2 = generatorOverride(ast, generatorOpts, code2, _generator().default);
            if (result2 !== void 0)
              results.push(result2);
          }
        }
      }
      let result;
      if (results.length === 0) {
        result = (0, _generator().default)(ast, generatorOpts, code2);
      } else if (results.length === 1) {
        result = results[0];
        if (typeof result.then === "function") {
          throw new Error(`You appear to be using an async codegen plugin, which your current version of Babel does not support. If you're using a published plugin, you may need to upgrade your @babel/core version.`);
        }
      } else {
        throw new Error("More than one plugin attempted to override codegen.");
      }
      let {
        code: outputCode,
        decodedMap: outputMap = result.map
      } = result;
      if (result.__mergedMap) {
        outputMap = Object.assign({}, result.map);
      } else {
        if (outputMap) {
          if (inputMap) {
            outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap, generatorOpts.sourceFileName);
          } else {
            outputMap = result.map;
          }
        }
      }
      if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
        outputCode += "\n" + _convertSourceMap().fromObject(outputMap).toComment();
      }
      if (opts.sourceMaps === "inline") {
        outputMap = null;
      }
      return {
        outputCode,
        outputMap
      };
    }
  }
});

// node_modules/@babel/core/lib/transformation/index.js
var require_transformation = __commonJS({
  "node_modules/@babel/core/lib/transformation/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.run = run;
    function _traverse() {
      const data3 = require_lib13();
      _traverse = function() {
        return data3;
      };
      return data3;
    }
    var _pluginPass = require_plugin_pass();
    var _blockHoistPlugin = require_block_hoist_plugin();
    var _normalizeOpts = require_normalize_opts();
    var _normalizeFile = require_normalize_file();
    var _generate = require_generate();
    var _deepArray = require_deep_array();
    function* run(config, code2, ast) {
      const file = yield* (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code2, ast);
      const opts = file.opts;
      try {
        yield* transformFile(file, config.passes);
      } catch (e) {
        var _opts$filename;
        e.message = `${(_opts$filename = opts.filename) != null ? _opts$filename : "unknown file"}: ${e.message}`;
        if (!e.code) {
          e.code = "BABEL_TRANSFORM_ERROR";
        }
        throw e;
      }
      let outputCode, outputMap;
      try {
        if (opts.code !== false) {
          ({
            outputCode,
            outputMap
          } = (0, _generate.default)(config.passes, file));
        }
      } catch (e) {
        var _opts$filename2;
        e.message = `${(_opts$filename2 = opts.filename) != null ? _opts$filename2 : "unknown file"}: ${e.message}`;
        if (!e.code) {
          e.code = "BABEL_GENERATE_ERROR";
        }
        throw e;
      }
      return {
        metadata: file.metadata,
        options: opts,
        ast: opts.ast === true ? file.ast : null,
        code: outputCode === void 0 ? null : outputCode,
        map: outputMap === void 0 ? null : outputMap,
        sourceType: file.ast.program.sourceType,
        externalDependencies: (0, _deepArray.flattenToSet)(config.externalDependencies)
      };
    }
    function* transformFile(file, pluginPasses) {
      for (const pluginPairs of pluginPasses) {
        const passPairs = [];
        const passes = [];
        const visitors = [];
        for (const plugin2 of pluginPairs.concat([(0, _blockHoistPlugin.default)()])) {
          const pass = new _pluginPass.default(file, plugin2.key, plugin2.options);
          passPairs.push([plugin2, pass]);
          passes.push(pass);
          visitors.push(plugin2.visitor);
        }
        for (const [plugin2, pass] of passPairs) {
          const fn = plugin2.pre;
          if (fn) {
            const result = fn.call(pass, file);
            yield* [];
            if (isThenable(result)) {
              throw new Error(`You appear to be using an plugin with an async .pre, which your current version of Babel does not support. If you're using a published plugin, you may need to upgrade your @babel/core version.`);
            }
          }
        }
        const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
        (0, _traverse().default)(file.ast, visitor, file.scope);
        for (const [plugin2, pass] of passPairs) {
          const fn = plugin2.post;
          if (fn) {
            const result = fn.call(pass, file);
            yield* [];
            if (isThenable(result)) {
              throw new Error(`You appear to be using an plugin with an async .post, which your current version of Babel does not support. If you're using a published plugin, you may need to upgrade your @babel/core version.`);
            }
          }
        }
      }
    }
    function isThenable(val) {
      return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
    }
  }
});

// node_modules/@babel/core/lib/transform-file.js
var require_transform_file = __commonJS({
  "node_modules/@babel/core/lib/transform-file.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.transformFile = transformFile;
    exports.transformFileAsync = transformFileAsync;
    exports.transformFileSync = transformFileSync;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _config = require_config();
    var _transformation = require_transformation();
    var fs = require_fs();
    var transformFileRunner = _gensync()(function* (filename, opts) {
      const options = Object.assign({}, opts, {
        filename
      });
      const config = yield* (0, _config.default)(options);
      if (config === null)
        return null;
      const code2 = yield* fs.readFile(filename, "utf8");
      return yield* (0, _transformation.run)(config, code2);
    });
    function transformFile(...args) {
      transformFileRunner.errback(...args);
    }
    function transformFileSync(...args) {
      return transformFileRunner.sync(...args);
    }
    function transformFileAsync(...args) {
      return transformFileRunner.async(...args);
    }
  }
});

// node_modules/@babel/core/lib/config/files/import.cjs
var require_import = __commonJS({
  "node_modules/@babel/core/lib/config/files/import.cjs"(exports, module2) {
    module2.exports = function import_(filepath) {
      return import(filepath);
    };
  }
});

// node_modules/@babel/preset-typescript/package.json
var require_package2 = __commonJS({
  "node_modules/@babel/preset-typescript/package.json"(exports, module2) {
    module2.exports = {
      name: "@babel/preset-typescript",
      version: "7.21.4",
      description: "Babel preset for TypeScript.",
      repository: {
        type: "git",
        url: "https://github.com/babel/babel.git",
        directory: "packages/babel-preset-typescript"
      },
      license: "MIT",
      publishConfig: {
        access: "public"
      },
      main: "./lib/index.js",
      keywords: [
        "babel-preset",
        "typescript"
      ],
      dependencies: {
        "@babel/helper-plugin-utils": "^7.20.2",
        "@babel/helper-validator-option": "^7.21.0",
        "@babel/plugin-syntax-jsx": "^7.21.4",
        "@babel/plugin-transform-modules-commonjs": "^7.21.2",
        "@babel/plugin-transform-typescript": "^7.21.3"
      },
      peerDependencies: {
        "@babel/core": "^7.0.0-0"
      },
      devDependencies: {
        "@babel/core": "^7.21.4",
        "@babel/helper-plugin-test-runner": "^7.18.6"
      },
      homepage: "https://babel.dev/docs/en/next/babel-preset-typescript",
      bugs: "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22area%3A%20typescript%22+is%3Aopen",
      engines: {
        node: ">=6.9.0"
      },
      author: "The Babel Team (https://babel.dev/team)",
      type: "commonjs"
    };
  }
});

// node_modules/@babel/helper-plugin-utils/lib/index.js
var require_lib20 = __commonJS({
  "node_modules/@babel/helper-plugin-utils/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.declare = declare;
    exports.declarePreset = void 0;
    var apiPolyfills = {
      assertVersion: (api) => (range) => {
        throwVersionError(range, api.version);
      },
      targets: () => () => {
        return {};
      },
      assumption: () => () => {
        return void 0;
      }
    };
    function declare(builder) {
      return (api, options, dirname) => {
        var _clonedApi2;
        let clonedApi;
        for (const name2 of Object.keys(apiPolyfills)) {
          var _clonedApi;
          if (api[name2])
            continue;
          clonedApi = (_clonedApi = clonedApi) != null ? _clonedApi : copyApiObject(api);
          clonedApi[name2] = apiPolyfills[name2](clonedApi);
        }
        return builder((_clonedApi2 = clonedApi) != null ? _clonedApi2 : api, options || {}, dirname);
      };
    }
    var declarePreset = declare;
    exports.declarePreset = declarePreset;
    function copyApiObject(api) {
      let proto = null;
      if (typeof api.version === "string" && /^7\./.test(api.version)) {
        proto = Object.getPrototypeOf(api);
        if (proto && (!has2(proto, "version") || !has2(proto, "transform") || !has2(proto, "template") || !has2(proto, "types"))) {
          proto = null;
        }
      }
      return Object.assign({}, proto, api);
    }
    function has2(obj, key2) {
      return Object.prototype.hasOwnProperty.call(obj, key2);
    }
    function throwVersionError(range, version3) {
      if (typeof range === "number") {
        if (!Number.isInteger(range)) {
          throw new Error("Expected string or integer value.");
        }
        range = `^${range}.0.0-0`;
      }
      if (typeof range !== "string") {
        throw new Error("Expected string or integer value.");
      }
      const limit = Error.stackTraceLimit;
      if (typeof limit === "number" && limit < 25) {
        Error.stackTraceLimit = 25;
      }
      let err;
      if (version3.slice(0, 2) === "7.") {
        err = new Error(`Requires Babel "^7.0.0-beta.41", but was loaded with "${version3}". You'll need to update your @babel/core version.`);
      } else {
        err = new Error(`Requires Babel "${range}", but was loaded with "${version3}". If you are sure you have a compatible version of @babel/core, it is likely that something in your build process is loading the wrong version. Inspect the stack trace of this error to look for the first entry that doesn't mention "@babel/core" or "babel-core" to see what is calling Babel.`);
      }
      if (typeof limit === "number") {
        Error.stackTraceLimit = limit;
      }
      throw Object.assign(err, {
        code: "BABEL_VERSION_UNSUPPORTED",
        version: version3,
        range
      });
    }
  }
});

// node_modules/@babel/plugin-syntax-typescript/lib/index.js
var require_lib21 = __commonJS({
  "node_modules/@babel/plugin-syntax-typescript/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperPluginUtils = require_lib20();
    {
      removePlugin = function(plugins, name2) {
        const indices = [];
        plugins.forEach((plugin2, i) => {
          const n = Array.isArray(plugin2) ? plugin2[0] : plugin2;
          if (n === name2) {
            indices.unshift(i);
          }
        });
        for (const i of indices) {
          plugins.splice(i, 1);
        }
      };
    }
    var removePlugin;
    var _default = (0, _helperPluginUtils.declare)((api, opts) => {
      api.assertVersion(7);
      const {
        disallowAmbiguousJSXLike,
        dts
      } = opts;
      {
        var {
          isTSX
        } = opts;
      }
      return {
        name: "syntax-typescript",
        manipulateOptions(opts2, parserOpts) {
          {
            const {
              plugins
            } = parserOpts;
            removePlugin(plugins, "flow");
            removePlugin(plugins, "jsx");
            plugins.push("objectRestSpread", "classProperties");
            if (isTSX) {
              plugins.push("jsx");
            }
          }
          parserOpts.plugins.push(["typescript", {
            disallowAmbiguousJSXLike,
            dts
          }]);
        }
      };
    });
    exports.default = _default;
  }
});

// node_modules/@babel/helper-member-expression-to-functions/lib/index.js
var require_lib22 = __commonJS({
  "node_modules/@babel/helper-member-expression-to-functions/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var _t = require_lib3();
    function _interopNamespace(e) {
      if (e && e.__esModule)
        return e;
      var n = /* @__PURE__ */ Object.create(null);
      if (e) {
        Object.keys(e).forEach(function(k) {
          if (k !== "default") {
            var d = Object.getOwnPropertyDescriptor(e, k);
            Object.defineProperty(n, k, d.get ? d : {
              enumerable: true,
              get: function() {
                return e[k];
              }
            });
          }
        });
      }
      n["default"] = e;
      return Object.freeze(n);
    }
    var _t__namespace = /* @__PURE__ */ _interopNamespace(_t);
    function willPathCastToBoolean(path) {
      const maybeWrapped = path;
      const {
        node: node2,
        parentPath
      } = maybeWrapped;
      if (parentPath.isLogicalExpression()) {
        const {
          operator,
          right
        } = parentPath.node;
        if (operator === "&&" || operator === "||" || operator === "??" && node2 === right) {
          return willPathCastToBoolean(parentPath);
        }
      }
      if (parentPath.isSequenceExpression()) {
        const {
          expressions
        } = parentPath.node;
        if (expressions[expressions.length - 1] === node2) {
          return willPathCastToBoolean(parentPath);
        } else {
          return true;
        }
      }
      return parentPath.isConditional({
        test: node2
      }) || parentPath.isUnaryExpression({
        operator: "!"
      }) || parentPath.isLoop({
        test: node2
      });
    }
    var {
      LOGICAL_OPERATORS,
      arrowFunctionExpression,
      assignmentExpression,
      binaryExpression,
      booleanLiteral,
      callExpression,
      cloneNode,
      conditionalExpression,
      identifier,
      isMemberExpression: isMemberExpression2,
      isOptionalCallExpression,
      isOptionalMemberExpression,
      isUpdateExpression,
      logicalExpression,
      memberExpression,
      nullLiteral,
      optionalCallExpression,
      optionalMemberExpression,
      sequenceExpression,
      updateExpression
    } = _t__namespace;
    var AssignmentMemoiser = class {
      constructor() {
        this._map = void 0;
        this._map = /* @__PURE__ */ new WeakMap();
      }
      has(key2) {
        return this._map.has(key2);
      }
      get(key2) {
        if (!this.has(key2))
          return;
        const record = this._map.get(key2);
        const {
          value: value2
        } = record;
        record.count--;
        if (record.count === 0) {
          return assignmentExpression("=", value2, key2);
        }
        return value2;
      }
      set(key2, value2, count) {
        return this._map.set(key2, {
          count,
          value: value2
        });
      }
    };
    function toNonOptional(path, base2) {
      const {
        node: node2
      } = path;
      if (isOptionalMemberExpression(node2)) {
        return memberExpression(base2, node2.property, node2.computed);
      }
      if (path.isOptionalCallExpression()) {
        const callee = path.get("callee");
        if (path.node.optional && callee.isOptionalMemberExpression()) {
          const object = callee.node.object;
          const context = path.scope.maybeGenerateMemoised(object);
          callee.get("object").replaceWith(assignmentExpression("=", context, object));
          return callExpression(memberExpression(base2, identifier("call")), [context, ...path.node.arguments]);
        }
        return callExpression(base2, path.node.arguments);
      }
      return path.node;
    }
    function isInDetachedTree(path) {
      while (path) {
        if (path.isProgram())
          break;
        const {
          parentPath,
          container,
          listKey
        } = path;
        const parentNode = parentPath.node;
        if (listKey) {
          if (container !== parentNode[listKey]) {
            return true;
          }
        } else {
          if (container !== parentNode)
            return true;
        }
        path = parentPath;
      }
      return false;
    }
    var handle = {
      memoise() {
      },
      handle(member, noDocumentAll) {
        const {
          node: node2,
          parent,
          parentPath,
          scope
        } = member;
        if (member.isOptionalMemberExpression()) {
          if (isInDetachedTree(member))
            return;
          const endPath = member.find(({
            node: node3,
            parent: parent2
          }) => {
            if (isOptionalMemberExpression(parent2)) {
              return parent2.optional || parent2.object !== node3;
            }
            if (isOptionalCallExpression(parent2)) {
              return node3 !== member.node && parent2.optional || parent2.callee !== node3;
            }
            return true;
          });
          if (scope.path.isPattern()) {
            endPath.replaceWith(callExpression(arrowFunctionExpression([], endPath.node), []));
            return;
          }
          const willEndPathCastToBoolean = willPathCastToBoolean(endPath);
          const rootParentPath = endPath.parentPath;
          if (rootParentPath.isUpdateExpression({
            argument: node2
          }) || rootParentPath.isAssignmentExpression({
            left: node2
          })) {
            throw member.buildCodeFrameError(`can't handle assignment`);
          }
          const isDeleteOperation = rootParentPath.isUnaryExpression({
            operator: "delete"
          });
          if (isDeleteOperation && endPath.isOptionalMemberExpression() && endPath.get("property").isPrivateName()) {
            throw member.buildCodeFrameError(`can't delete a private class element`);
          }
          let startingOptional = member;
          for (; ; ) {
            if (startingOptional.isOptionalMemberExpression()) {
              if (startingOptional.node.optional)
                break;
              startingOptional = startingOptional.get("object");
              continue;
            } else if (startingOptional.isOptionalCallExpression()) {
              if (startingOptional.node.optional)
                break;
              startingOptional = startingOptional.get("callee");
              continue;
            }
            throw new Error(`Internal error: unexpected ${startingOptional.node.type}`);
          }
          const startingNode = startingOptional.isOptionalMemberExpression() ? startingOptional.node.object : startingOptional.node.callee;
          const baseNeedsMemoised = scope.maybeGenerateMemoised(startingNode);
          const baseRef = baseNeedsMemoised != null ? baseNeedsMemoised : startingNode;
          const parentIsOptionalCall = parentPath.isOptionalCallExpression({
            callee: node2
          });
          const isOptionalCall = (parent2) => parentIsOptionalCall;
          const parentIsCall = parentPath.isCallExpression({
            callee: node2
          });
          startingOptional.replaceWith(toNonOptional(startingOptional, baseRef));
          if (isOptionalCall()) {
            if (parent.optional) {
              parentPath.replaceWith(this.optionalCall(member, parent.arguments));
            } else {
              parentPath.replaceWith(this.call(member, parent.arguments));
            }
          } else if (parentIsCall) {
            member.replaceWith(this.boundGet(member));
          } else if (this.delete && parentPath.isUnaryExpression({
            operator: "delete"
          })) {
            parentPath.replaceWith(this.delete(member));
          } else {
            member.replaceWith(this.get(member));
          }
          let regular = member.node;
          for (let current3 = member; current3 !== endPath; ) {
            const parentPath2 = current3.parentPath;
            if (parentPath2 === endPath && isOptionalCall() && parent.optional) {
              regular = parentPath2.node;
              break;
            }
            regular = toNonOptional(parentPath2, regular);
            current3 = parentPath2;
          }
          let context;
          const endParentPath = endPath.parentPath;
          if (isMemberExpression2(regular) && endParentPath.isOptionalCallExpression({
            callee: endPath.node,
            optional: true
          })) {
            const {
              object
            } = regular;
            context = member.scope.maybeGenerateMemoised(object);
            if (context) {
              regular.object = assignmentExpression("=", context, object);
            }
          }
          let replacementPath = endPath;
          if (isDeleteOperation) {
            replacementPath = endParentPath;
            regular = endParentPath.node;
          }
          const baseMemoised = baseNeedsMemoised ? assignmentExpression("=", cloneNode(baseRef), cloneNode(startingNode)) : cloneNode(baseRef);
          if (willEndPathCastToBoolean) {
            let nonNullishCheck;
            if (noDocumentAll) {
              nonNullishCheck = binaryExpression("!=", baseMemoised, nullLiteral());
            } else {
              nonNullishCheck = logicalExpression("&&", binaryExpression("!==", baseMemoised, nullLiteral()), binaryExpression("!==", cloneNode(baseRef), scope.buildUndefinedNode()));
            }
            replacementPath.replaceWith(logicalExpression("&&", nonNullishCheck, regular));
          } else {
            let nullishCheck;
            if (noDocumentAll) {
              nullishCheck = binaryExpression("==", baseMemoised, nullLiteral());
            } else {
              nullishCheck = logicalExpression("||", binaryExpression("===", baseMemoised, nullLiteral()), binaryExpression("===", cloneNode(baseRef), scope.buildUndefinedNode()));
            }
            replacementPath.replaceWith(conditionalExpression(nullishCheck, isDeleteOperation ? booleanLiteral(true) : scope.buildUndefinedNode(), regular));
          }
          if (context) {
            const endParent = endParentPath.node;
            endParentPath.replaceWith(optionalCallExpression(optionalMemberExpression(endParent.callee, identifier("call"), false, true), [cloneNode(context), ...endParent.arguments], false));
          }
          return;
        }
        if (isUpdateExpression(parent, {
          argument: node2
        })) {
          if (this.simpleSet) {
            member.replaceWith(this.simpleSet(member));
            return;
          }
          const {
            operator,
            prefix
          } = parent;
          this.memoise(member, 2);
          const ref3 = scope.generateUidIdentifierBasedOnNode(node2);
          scope.push({
            id: ref3
          });
          const seq = [assignmentExpression("=", cloneNode(ref3), this.get(member))];
          if (prefix) {
            seq.push(updateExpression(operator, cloneNode(ref3), prefix));
            const value2 = sequenceExpression(seq);
            parentPath.replaceWith(this.set(member, value2));
            return;
          } else {
            const ref22 = scope.generateUidIdentifierBasedOnNode(node2);
            scope.push({
              id: ref22
            });
            seq.push(assignmentExpression("=", cloneNode(ref22), updateExpression(operator, cloneNode(ref3), prefix)), cloneNode(ref3));
            const value2 = sequenceExpression(seq);
            parentPath.replaceWith(sequenceExpression([this.set(member, value2), cloneNode(ref22)]));
            return;
          }
        }
        if (parentPath.isAssignmentExpression({
          left: node2
        })) {
          if (this.simpleSet) {
            member.replaceWith(this.simpleSet(member));
            return;
          }
          const {
            operator,
            right: value2
          } = parentPath.node;
          if (operator === "=") {
            parentPath.replaceWith(this.set(member, value2));
          } else {
            const operatorTrunc = operator.slice(0, -1);
            if (LOGICAL_OPERATORS.includes(operatorTrunc)) {
              this.memoise(member, 1);
              parentPath.replaceWith(logicalExpression(operatorTrunc, this.get(member), this.set(member, value2)));
            } else {
              this.memoise(member, 2);
              parentPath.replaceWith(this.set(member, binaryExpression(operatorTrunc, this.get(member), value2)));
            }
          }
          return;
        }
        if (parentPath.isCallExpression({
          callee: node2
        })) {
          parentPath.replaceWith(this.call(member, parentPath.node.arguments));
          return;
        }
        if (parentPath.isOptionalCallExpression({
          callee: node2
        })) {
          if (scope.path.isPattern()) {
            parentPath.replaceWith(callExpression(arrowFunctionExpression([], parentPath.node), []));
            return;
          }
          parentPath.replaceWith(this.optionalCall(member, parentPath.node.arguments));
          return;
        }
        if (this.delete && parentPath.isUnaryExpression({
          operator: "delete"
        })) {
          parentPath.replaceWith(this.delete(member));
          return;
        }
        if (parentPath.isForXStatement({
          left: node2
        }) || parentPath.isObjectProperty({
          value: node2
        }) && parentPath.parentPath.isObjectPattern() || parentPath.isAssignmentPattern({
          left: node2
        }) && parentPath.parentPath.isObjectProperty({
          value: parent
        }) && parentPath.parentPath.parentPath.isObjectPattern() || parentPath.isArrayPattern() || parentPath.isAssignmentPattern({
          left: node2
        }) && parentPath.parentPath.isArrayPattern() || parentPath.isRestElement()) {
          member.replaceWith(this.destructureSet(member));
          return;
        }
        if (parentPath.isTaggedTemplateExpression()) {
          member.replaceWith(this.boundGet(member));
        } else {
          member.replaceWith(this.get(member));
        }
      }
    };
    function memberExpressionToFunctions(path, visitor, state) {
      path.traverse(visitor, Object.assign({}, handle, state, {
        memoiser: new AssignmentMemoiser()
      }));
    }
    exports["default"] = memberExpressionToFunctions;
  }
});

// node_modules/@babel/helper-optimise-call-expression/lib/index.js
var require_lib23 = __commonJS({
  "node_modules/@babel/helper-optimise-call-expression/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = optimiseCallExpression;
    var _t = require_lib3();
    var {
      callExpression,
      identifier,
      isIdentifier: isIdentifier3,
      isSpreadElement,
      memberExpression,
      optionalCallExpression,
      optionalMemberExpression
    } = _t;
    function optimiseCallExpression(callee, thisNode, args, optional) {
      if (args.length === 1 && isSpreadElement(args[0]) && isIdentifier3(args[0].argument, {
        name: "arguments"
      })) {
        if (optional) {
          return optionalCallExpression(optionalMemberExpression(callee, identifier("apply"), false, true), [thisNode, args[0].argument], false);
        }
        return callExpression(memberExpression(callee, identifier("apply")), [thisNode, args[0].argument]);
      } else {
        if (optional) {
          return optionalCallExpression(optionalMemberExpression(callee, identifier("call"), false, true), [thisNode, ...args], false);
        }
        return callExpression(memberExpression(callee, identifier("call")), [thisNode, ...args]);
      }
    }
  }
});

// node_modules/@babel/helper-replace-supers/lib/index.js
var require_lib24 = __commonJS({
  "node_modules/@babel/helper-replace-supers/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    Object.defineProperty(exports, "environmentVisitor", {
      enumerable: true,
      get: function() {
        return _helperEnvironmentVisitor.default;
      }
    });
    Object.defineProperty(exports, "skipAllButComputedKey", {
      enumerable: true,
      get: function() {
        return _helperEnvironmentVisitor.skipAllButComputedKey;
      }
    });
    var _helperEnvironmentVisitor = require_lib6();
    var _helperMemberExpressionToFunctions = require_lib22();
    var _helperOptimiseCallExpression = require_lib23();
    var _template = require_lib11();
    var _traverse = require_lib13();
    var _t = require_lib3();
    var {
      assignmentExpression,
      booleanLiteral,
      callExpression,
      cloneNode,
      identifier,
      memberExpression,
      sequenceExpression,
      stringLiteral: stringLiteral2,
      thisExpression
    } = _t;
    function getPrototypeOfExpression(objectRef, isStatic, file, isPrivateMethod) {
      objectRef = cloneNode(objectRef);
      const targetRef = isStatic || isPrivateMethod ? objectRef : memberExpression(objectRef, identifier("prototype"));
      return callExpression(file.addHelper("getPrototypeOf"), [targetRef]);
    }
    var visitor = _traverse.default.visitors.merge([_helperEnvironmentVisitor.default, {
      Super(path, state) {
        const {
          node: node2,
          parentPath
        } = path;
        if (!parentPath.isMemberExpression({
          object: node2
        }))
          return;
        state.handle(parentPath);
      }
    }]);
    var unshadowSuperBindingVisitor = _traverse.default.visitors.merge([_helperEnvironmentVisitor.default, {
      Scopable(path, {
        refName
      }) {
        const binding = path.scope.getOwnBinding(refName);
        if (binding && binding.identifier.name === refName) {
          path.scope.rename(refName);
        }
      }
    }]);
    var specHandlers = {
      memoise(superMember, count) {
        const {
          scope,
          node: node2
        } = superMember;
        const {
          computed,
          property
        } = node2;
        if (!computed) {
          return;
        }
        const memo = scope.maybeGenerateMemoised(property);
        if (!memo) {
          return;
        }
        this.memoiser.set(property, memo, count);
      },
      prop(superMember) {
        const {
          computed,
          property
        } = superMember.node;
        if (this.memoiser.has(property)) {
          return cloneNode(this.memoiser.get(property));
        }
        if (computed) {
          return cloneNode(property);
        }
        return stringLiteral2(property.name);
      },
      get(superMember) {
        return this._get(superMember, this._getThisRefs());
      },
      _get(superMember, thisRefs) {
        const proto = getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file, this.isPrivateMethod);
        return callExpression(this.file.addHelper("get"), [
          thisRefs.memo ? sequenceExpression([thisRefs.memo, proto]) : proto,
          this.prop(superMember),
          thisRefs.this
        ]);
      },
      _getThisRefs() {
        if (!this.isDerivedConstructor) {
          return {
            this: thisExpression()
          };
        }
        const thisRef = this.scope.generateDeclaredUidIdentifier("thisSuper");
        return {
          memo: assignmentExpression("=", thisRef, thisExpression()),
          this: cloneNode(thisRef)
        };
      },
      set(superMember, value2) {
        const thisRefs = this._getThisRefs();
        const proto = getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file, this.isPrivateMethod);
        return callExpression(this.file.addHelper("set"), [
          thisRefs.memo ? sequenceExpression([thisRefs.memo, proto]) : proto,
          this.prop(superMember),
          value2,
          thisRefs.this,
          booleanLiteral(superMember.isInStrictMode())
        ]);
      },
      destructureSet(superMember) {
        throw superMember.buildCodeFrameError(`Destructuring to a super field is not supported yet.`);
      },
      call(superMember, args) {
        const thisRefs = this._getThisRefs();
        return (0, _helperOptimiseCallExpression.default)(this._get(superMember, thisRefs), cloneNode(thisRefs.this), args, false);
      },
      optionalCall(superMember, args) {
        const thisRefs = this._getThisRefs();
        return (0, _helperOptimiseCallExpression.default)(this._get(superMember, thisRefs), cloneNode(thisRefs.this), args, true);
      },
      delete(superMember) {
        if (superMember.node.computed) {
          return sequenceExpression([callExpression(this.file.addHelper("toPropertyKey"), [cloneNode(superMember.node.property)]), _template.default.expression.ast`
          function () { throw new ReferenceError("'delete super[expr]' is invalid"); }()
        `]);
        } else {
          return _template.default.expression.ast`
        function () { throw new ReferenceError("'delete super.prop' is invalid"); }()
      `;
        }
      }
    };
    var looseHandlers = Object.assign({}, specHandlers, {
      prop(superMember) {
        const {
          property
        } = superMember.node;
        if (this.memoiser.has(property)) {
          return cloneNode(this.memoiser.get(property));
        }
        return cloneNode(property);
      },
      get(superMember) {
        const {
          isStatic,
          getSuperRef
        } = this;
        const {
          computed
        } = superMember.node;
        const prop = this.prop(superMember);
        let object;
        if (isStatic) {
          var _getSuperRef;
          object = (_getSuperRef = getSuperRef()) != null ? _getSuperRef : memberExpression(identifier("Function"), identifier("prototype"));
        } else {
          var _getSuperRef2;
          object = memberExpression((_getSuperRef2 = getSuperRef()) != null ? _getSuperRef2 : identifier("Object"), identifier("prototype"));
        }
        return memberExpression(object, prop, computed);
      },
      set(superMember, value2) {
        const {
          computed
        } = superMember.node;
        const prop = this.prop(superMember);
        return assignmentExpression("=", memberExpression(thisExpression(), prop, computed), value2);
      },
      destructureSet(superMember) {
        const {
          computed
        } = superMember.node;
        const prop = this.prop(superMember);
        return memberExpression(thisExpression(), prop, computed);
      },
      call(superMember, args) {
        return (0, _helperOptimiseCallExpression.default)(this.get(superMember), thisExpression(), args, false);
      },
      optionalCall(superMember, args) {
        return (0, _helperOptimiseCallExpression.default)(this.get(superMember), thisExpression(), args, true);
      }
    });
    var ReplaceSupers = class {
      constructor(opts) {
        var _opts$constantSuper;
        const path = opts.methodPath;
        this.methodPath = path;
        this.isDerivedConstructor = path.isClassMethod({
          kind: "constructor"
        }) && !!opts.superRef;
        this.isStatic = path.isObjectMethod() || path.node.static || (path.isStaticBlock == null ? void 0 : path.isStaticBlock());
        this.isPrivateMethod = path.isPrivate() && path.isMethod();
        this.file = opts.file;
        this.constantSuper = (_opts$constantSuper = opts.constantSuper) != null ? _opts$constantSuper : opts.isLoose;
        this.opts = opts;
      }
      getObjectRef() {
        return cloneNode(this.opts.objectRef || this.opts.getObjectRef());
      }
      getSuperRef() {
        if (this.opts.superRef)
          return cloneNode(this.opts.superRef);
        if (this.opts.getSuperRef) {
          return cloneNode(this.opts.getSuperRef());
        }
      }
      replace() {
        if (this.opts.refToPreserve) {
          this.methodPath.traverse(unshadowSuperBindingVisitor, {
            refName: this.opts.refToPreserve.name
          });
        }
        const handler = this.constantSuper ? looseHandlers : specHandlers;
        (0, _helperMemberExpressionToFunctions.default)(this.methodPath, visitor, Object.assign({
          file: this.file,
          scope: this.methodPath.scope,
          isDerivedConstructor: this.isDerivedConstructor,
          isStatic: this.isStatic,
          isPrivateMethod: this.isPrivateMethod,
          getObjectRef: this.getObjectRef.bind(this),
          getSuperRef: this.getSuperRef.bind(this),
          boundGet: handler.get
        }, handler));
      }
    };
    exports.default = ReplaceSupers;
  }
});

// node_modules/@babel/helper-annotate-as-pure/lib/index.js
var require_lib25 = __commonJS({
  "node_modules/@babel/helper-annotate-as-pure/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = annotateAsPure;
    var _t = require_lib3();
    var {
      addComment
    } = _t;
    var PURE_ANNOTATION = "#__PURE__";
    var isPureAnnotated = ({
      leadingComments
    }) => !!leadingComments && leadingComments.some((comment2) => /[@#]__PURE__/.test(comment2.value));
    function annotateAsPure(pathOrNode) {
      const node2 = pathOrNode["node"] || pathOrNode;
      if (isPureAnnotated(node2)) {
        return;
      }
      addComment(node2, "leading", PURE_ANNOTATION);
    }
  }
});

// node_modules/@babel/helper-skip-transparent-expression-wrappers/lib/index.js
var require_lib26 = __commonJS({
  "node_modules/@babel/helper-skip-transparent-expression-wrappers/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isTransparentExprWrapper = isTransparentExprWrapper;
    exports.skipTransparentExprWrapperNodes = skipTransparentExprWrapperNodes;
    exports.skipTransparentExprWrappers = skipTransparentExprWrappers;
    var _t = require_lib3();
    var {
      isParenthesizedExpression,
      isTSAsExpression,
      isTSNonNullExpression,
      isTSSatisfiesExpression,
      isTSTypeAssertion,
      isTypeCastExpression
    } = _t;
    function isTransparentExprWrapper(node2) {
      return isTSAsExpression(node2) || isTSSatisfiesExpression(node2) || isTSTypeAssertion(node2) || isTSNonNullExpression(node2) || isTypeCastExpression(node2) || isParenthesizedExpression(node2);
    }
    function skipTransparentExprWrappers(path) {
      while (isTransparentExprWrapper(path.node)) {
        path = path.get("expression");
      }
      return path;
    }
    function skipTransparentExprWrapperNodes(node2) {
      while (isTransparentExprWrapper(node2)) {
        node2 = node2.expression;
      }
      return node2;
    }
  }
});

// node_modules/@babel/helper-create-class-features-plugin/lib/typescript.js
var require_typescript3 = __commonJS({
  "node_modules/@babel/helper-create-class-features-plugin/lib/typescript.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.assertFieldTransformed = assertFieldTransformed;
    function assertFieldTransformed(path) {
      if (path.node.declare) {
        throw path.buildCodeFrameError(`TypeScript 'declare' fields must first be transformed by @babel/plugin-transform-typescript.
If you have already enabled that plugin (or '@babel/preset-typescript'), make sure that it runs before any plugin related to additional class features:
 - @babel/plugin-proposal-class-properties
 - @babel/plugin-proposal-private-methods
 - @babel/plugin-proposal-decorators`);
      }
    }
  }
});

// node_modules/@babel/helper-create-class-features-plugin/lib/fields.js
var require_fields = __commonJS({
  "node_modules/@babel/helper-create-class-features-plugin/lib/fields.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.buildCheckInRHS = buildCheckInRHS;
    exports.buildFieldsInitNodes = buildFieldsInitNodes;
    exports.buildPrivateNamesMap = buildPrivateNamesMap;
    exports.buildPrivateNamesNodes = buildPrivateNamesNodes;
    exports.transformPrivateNamesUsage = transformPrivateNamesUsage;
    var _core = require_lib32();
    var _helperReplaceSupers = require_lib24();
    var _helperEnvironmentVisitor = require_lib6();
    var _helperMemberExpressionToFunctions = require_lib22();
    var _helperOptimiseCallExpression = require_lib23();
    var _helperAnnotateAsPure = require_lib25();
    var _helperSkipTransparentExpressionWrappers = require_lib26();
    var ts = require_typescript3();
    function buildPrivateNamesMap(props) {
      const privateNamesMap = /* @__PURE__ */ new Map();
      for (const prop of props) {
        if (prop.isPrivate()) {
          const {
            name: name2
          } = prop.node.key.id;
          const update = privateNamesMap.has(name2) ? privateNamesMap.get(name2) : {
            id: prop.scope.generateUidIdentifier(name2),
            static: prop.node.static,
            method: !prop.isProperty()
          };
          if (prop.isClassPrivateMethod()) {
            if (prop.node.kind === "get") {
              update.getId = prop.scope.generateUidIdentifier(`get_${name2}`);
            } else if (prop.node.kind === "set") {
              update.setId = prop.scope.generateUidIdentifier(`set_${name2}`);
            } else if (prop.node.kind === "method") {
              update.methodId = prop.scope.generateUidIdentifier(name2);
            }
          }
          privateNamesMap.set(name2, update);
        }
      }
      return privateNamesMap;
    }
    function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, privateFieldsAsSymbols, state) {
      const initNodes = [];
      for (const [name2, value2] of privateNamesMap) {
        const {
          static: isStatic,
          method: isMethod,
          getId,
          setId
        } = value2;
        const isAccessor = getId || setId;
        const id = _core.types.cloneNode(value2.id);
        let init;
        if (privateFieldsAsProperties) {
          init = _core.types.callExpression(state.addHelper("classPrivateFieldLooseKey"), [_core.types.stringLiteral(name2)]);
        } else if (privateFieldsAsSymbols) {
          init = _core.types.callExpression(_core.types.identifier("Symbol"), [_core.types.stringLiteral(name2)]);
        } else if (!isStatic) {
          init = _core.types.newExpression(_core.types.identifier(!isMethod || isAccessor ? "WeakMap" : "WeakSet"), []);
        }
        if (init) {
          (0, _helperAnnotateAsPure.default)(init);
          initNodes.push(_core.template.statement.ast`var ${id} = ${init}`);
        }
      }
      return initNodes;
    }
    function privateNameVisitorFactory(visitor) {
      const nestedVisitor = _core.traverse.visitors.merge([Object.assign({}, visitor), _helperEnvironmentVisitor.default]);
      const privateNameVisitor2 = Object.assign({}, visitor, {
        Class(path) {
          const {
            privateNamesMap
          } = this;
          const body = path.get("body.body");
          const visiblePrivateNames = new Map(privateNamesMap);
          const redeclared = [];
          for (const prop of body) {
            if (!prop.isPrivate())
              continue;
            const {
              name: name2
            } = prop.node.key.id;
            visiblePrivateNames.delete(name2);
            redeclared.push(name2);
          }
          if (!redeclared.length) {
            return;
          }
          path.get("body").traverse(nestedVisitor, Object.assign({}, this, {
            redeclared
          }));
          path.traverse(privateNameVisitor2, Object.assign({}, this, {
            privateNamesMap: visiblePrivateNames
          }));
          path.skipKey("body");
        }
      });
      return privateNameVisitor2;
    }
    var privateNameVisitor = privateNameVisitorFactory({
      PrivateName(path, {
        noDocumentAll
      }) {
        const {
          privateNamesMap,
          redeclared
        } = this;
        const {
          node: node2,
          parentPath
        } = path;
        if (!parentPath.isMemberExpression({
          property: node2
        }) && !parentPath.isOptionalMemberExpression({
          property: node2
        })) {
          return;
        }
        const {
          name: name2
        } = node2.id;
        if (!privateNamesMap.has(name2))
          return;
        if (redeclared && redeclared.includes(name2))
          return;
        this.handle(parentPath, noDocumentAll);
      }
    });
    function unshadow(name2, scope, innerBinding) {
      while ((_scope = scope) != null && _scope.hasBinding(name2) && !scope.bindingIdentifierEquals(name2, innerBinding)) {
        var _scope;
        scope.rename(name2);
        scope = scope.parent;
      }
    }
    function buildCheckInRHS(rhs, file, inRHSIsObject) {
      if (inRHSIsObject || !(file.availableHelper != null && file.availableHelper("checkInRHS")))
        return rhs;
      return _core.types.callExpression(file.addHelper("checkInRHS"), [rhs]);
    }
    var privateInVisitor = privateNameVisitorFactory({
      BinaryExpression(path, {
        file
      }) {
        const {
          operator,
          left,
          right
        } = path.node;
        if (operator !== "in")
          return;
        if (!_core.types.isPrivateName(left))
          return;
        const {
          privateFieldsAsProperties,
          privateNamesMap,
          redeclared
        } = this;
        const {
          name: name2
        } = left.id;
        if (!privateNamesMap.has(name2))
          return;
        if (redeclared && redeclared.includes(name2))
          return;
        unshadow(this.classRef.name, path.scope, this.innerBinding);
        if (privateFieldsAsProperties) {
          const {
            id: id2
          } = privateNamesMap.get(name2);
          path.replaceWith(_core.template.expression.ast`
        Object.prototype.hasOwnProperty.call(${buildCheckInRHS(right, file)}, ${_core.types.cloneNode(id2)})
      `);
          return;
        }
        const {
          id,
          static: isStatic
        } = privateNamesMap.get(name2);
        if (isStatic) {
          path.replaceWith(_core.template.expression.ast`${buildCheckInRHS(right, file)} === ${_core.types.cloneNode(this.classRef)}`);
          return;
        }
        path.replaceWith(_core.template.expression.ast`${_core.types.cloneNode(id)}.has(${buildCheckInRHS(right, file)})`);
      }
    });
    var privateNameHandlerSpec = {
      memoise(member, count) {
        const {
          scope
        } = member;
        const {
          object
        } = member.node;
        const memo = scope.maybeGenerateMemoised(object);
        if (!memo) {
          return;
        }
        this.memoiser.set(object, memo, count);
      },
      receiver(member) {
        const {
          object
        } = member.node;
        if (this.memoiser.has(object)) {
          return _core.types.cloneNode(this.memoiser.get(object));
        }
        return _core.types.cloneNode(object);
      },
      get(member) {
        const {
          classRef,
          privateNamesMap,
          file,
          innerBinding
        } = this;
        const {
          name: name2
        } = member.node.property.id;
        const {
          id,
          static: isStatic,
          method: isMethod,
          methodId,
          getId,
          setId
        } = privateNamesMap.get(name2);
        const isAccessor = getId || setId;
        if (isStatic) {
          const helperName = isMethod && !isAccessor ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet";
          unshadow(classRef.name, member.scope, innerBinding);
          return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]);
        }
        if (isMethod) {
          if (isAccessor) {
            if (!getId && setId) {
              if (file.availableHelper("writeOnlyError")) {
                return _core.types.sequenceExpression([this.receiver(member), _core.types.callExpression(file.addHelper("writeOnlyError"), [_core.types.stringLiteral(`#${name2}`)])]);
              }
              console.warn(`@babel/helpers is outdated, update it to silence this warning.`);
            }
            return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]);
          }
          return _core.types.callExpression(file.addHelper("classPrivateMethodGet"), [this.receiver(member), _core.types.cloneNode(id), _core.types.cloneNode(methodId)]);
        }
        return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]);
      },
      boundGet(member) {
        this.memoise(member, 1);
        return _core.types.callExpression(_core.types.memberExpression(this.get(member), _core.types.identifier("bind")), [this.receiver(member)]);
      },
      set(member, value2) {
        const {
          classRef,
          privateNamesMap,
          file
        } = this;
        const {
          name: name2
        } = member.node.property.id;
        const {
          id,
          static: isStatic,
          method: isMethod,
          setId,
          getId
        } = privateNamesMap.get(name2);
        const isAccessor = getId || setId;
        if (isStatic) {
          const helperName = isMethod && !isAccessor ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet";
          return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id), value2]);
        }
        if (isMethod) {
          if (setId) {
            return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value2]);
          }
          return _core.types.sequenceExpression([this.receiver(member), value2, _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name2}`)])]);
        }
        return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value2]);
      },
      destructureSet(member) {
        const {
          classRef,
          privateNamesMap,
          file
        } = this;
        const {
          name: name2
        } = member.node.property.id;
        const {
          id,
          static: isStatic
        } = privateNamesMap.get(name2);
        if (isStatic) {
          try {
            var helper = file.addHelper("classStaticPrivateFieldDestructureSet");
          } catch (_unused) {
            throw new Error("Babel can not transpile `[C.#p] = [0]` with @babel/helpers < 7.13.10, \nplease update @babel/helpers to the latest version.");
          }
          return _core.types.memberExpression(_core.types.callExpression(helper, [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]), _core.types.identifier("value"));
        }
        return _core.types.memberExpression(_core.types.callExpression(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), _core.types.cloneNode(id)]), _core.types.identifier("value"));
      },
      call(member, args) {
        this.memoise(member, 1);
        return (0, _helperOptimiseCallExpression.default)(this.get(member), this.receiver(member), args, false);
      },
      optionalCall(member, args) {
        this.memoise(member, 1);
        return (0, _helperOptimiseCallExpression.default)(this.get(member), this.receiver(member), args, true);
      }
    };
    var privateNameHandlerLoose = {
      get(member) {
        const {
          privateNamesMap,
          file
        } = this;
        const {
          object
        } = member.node;
        const {
          name: name2
        } = member.node.property.id;
        return _core.template.expression`BASE(REF, PROP)[PROP]`({
          BASE: file.addHelper("classPrivateFieldLooseBase"),
          REF: _core.types.cloneNode(object),
          PROP: _core.types.cloneNode(privateNamesMap.get(name2).id)
        });
      },
      set() {
        throw new Error("private name handler with loose = true don't need set()");
      },
      boundGet(member) {
        return _core.types.callExpression(_core.types.memberExpression(this.get(member), _core.types.identifier("bind")), [_core.types.cloneNode(member.node.object)]);
      },
      simpleSet(member) {
        return this.get(member);
      },
      destructureSet(member) {
        return this.get(member);
      },
      call(member, args) {
        return _core.types.callExpression(this.get(member), args);
      },
      optionalCall(member, args) {
        return _core.types.optionalCallExpression(this.get(member), args, true);
      }
    };
    function transformPrivateNamesUsage(ref3, path, privateNamesMap, {
      privateFieldsAsProperties,
      noDocumentAll,
      innerBinding
    }, state) {
      if (!privateNamesMap.size)
        return;
      const body = path.get("body");
      const handler = privateFieldsAsProperties ? privateNameHandlerLoose : privateNameHandlerSpec;
      (0, _helperMemberExpressionToFunctions.default)(body, privateNameVisitor, Object.assign({
        privateNamesMap,
        classRef: ref3,
        file: state
      }, handler, {
        noDocumentAll,
        innerBinding
      }));
      body.traverse(privateInVisitor, {
        privateNamesMap,
        classRef: ref3,
        file: state,
        privateFieldsAsProperties,
        innerBinding
      });
    }
    function buildPrivateFieldInitLoose(ref3, prop, privateNamesMap) {
      const {
        id
      } = privateNamesMap.get(prop.node.key.id.name);
      const value2 = prop.node.value || prop.scope.buildUndefinedNode();
      return inheritPropComments(_core.template.statement.ast`
      Object.defineProperty(${ref3}, ${_core.types.cloneNode(id)}, {
        // configurable is false by default
        // enumerable is false by default
        writable: true,
        value: ${value2}
      });
    `, prop);
    }
    function buildPrivateInstanceFieldInitSpec(ref3, prop, privateNamesMap, state) {
      const {
        id
      } = privateNamesMap.get(prop.node.key.id.name);
      const value2 = prop.node.value || prop.scope.buildUndefinedNode();
      {
        if (!state.availableHelper("classPrivateFieldInitSpec")) {
          return inheritPropComments(_core.template.statement.ast`${_core.types.cloneNode(id)}.set(${ref3}, {
          // configurable is always false for private elements
          // enumerable is always false for private elements
          writable: true,
          value: ${value2},
        })`, prop);
        }
      }
      const helper = state.addHelper("classPrivateFieldInitSpec");
      return inheritPropComments(_core.template.statement.ast`${helper}(
      ${_core.types.thisExpression()},
      ${_core.types.cloneNode(id)},
      {
        writable: true,
        value: ${value2}
      },
    )`, prop);
    }
    function buildPrivateStaticFieldInitSpec(prop, privateNamesMap) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        id,
        getId,
        setId,
        initAdded
      } = privateName;
      const isAccessor = getId || setId;
      if (!prop.isProperty() && (initAdded || !isAccessor))
        return;
      if (isAccessor) {
        privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
          initAdded: true
        }));
        return inheritPropComments(_core.template.statement.ast`
        var ${_core.types.cloneNode(id)} = {
          // configurable is false by default
          // enumerable is false by default
          // writable is false by default
          get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
          set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
        }
      `, prop);
      }
      const value2 = prop.node.value || prop.scope.buildUndefinedNode();
      return inheritPropComments(_core.template.statement.ast`
      var ${_core.types.cloneNode(id)} = {
        // configurable is false by default
        // enumerable is false by default
        writable: true,
        value: ${value2}
      };
    `, prop);
    }
    function buildPrivateMethodInitLoose(ref3, prop, privateNamesMap) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        methodId,
        id,
        getId,
        setId,
        initAdded
      } = privateName;
      if (initAdded)
        return;
      if (methodId) {
        return inheritPropComments(_core.template.statement.ast`
        Object.defineProperty(${ref3}, ${id}, {
          // configurable is false by default
          // enumerable is false by default
          // writable is false by default
          value: ${methodId.name}
        });
      `, prop);
      }
      const isAccessor = getId || setId;
      if (isAccessor) {
        privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
          initAdded: true
        }));
        return inheritPropComments(_core.template.statement.ast`
        Object.defineProperty(${ref3}, ${id}, {
          // configurable is false by default
          // enumerable is false by default
          // writable is false by default
          get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
          set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
        });
      `, prop);
      }
    }
    function buildPrivateInstanceMethodInitSpec(ref3, prop, privateNamesMap, state) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        getId,
        setId,
        initAdded
      } = privateName;
      if (initAdded)
        return;
      const isAccessor = getId || setId;
      if (isAccessor) {
        return buildPrivateAccessorInitialization(ref3, prop, privateNamesMap, state);
      }
      return buildPrivateInstanceMethodInitialization(ref3, prop, privateNamesMap, state);
    }
    function buildPrivateAccessorInitialization(ref3, prop, privateNamesMap, state) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        id,
        getId,
        setId
      } = privateName;
      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
        initAdded: true
      }));
      {
        if (!state.availableHelper("classPrivateFieldInitSpec")) {
          return inheritPropComments(_core.template.statement.ast`
          ${id}.set(${ref3}, {
            get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
            set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
          });
        `, prop);
        }
      }
      const helper = state.addHelper("classPrivateFieldInitSpec");
      return inheritPropComments(_core.template.statement.ast`${helper}(
      ${_core.types.thisExpression()},
      ${_core.types.cloneNode(id)},
      {
        get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
        set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
      },
    )`, prop);
    }
    function buildPrivateInstanceMethodInitialization(ref3, prop, privateNamesMap, state) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        id
      } = privateName;
      {
        if (!state.availableHelper("classPrivateMethodInitSpec")) {
          return inheritPropComments(_core.template.statement.ast`${id}.add(${ref3})`, prop);
        }
      }
      const helper = state.addHelper("classPrivateMethodInitSpec");
      return inheritPropComments(_core.template.statement.ast`${helper}(
      ${_core.types.thisExpression()},
      ${_core.types.cloneNode(id)}
    )`, prop);
    }
    function buildPublicFieldInitLoose(ref3, prop) {
      const {
        key: key2,
        computed
      } = prop.node;
      const value2 = prop.node.value || prop.scope.buildUndefinedNode();
      return inheritPropComments(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.memberExpression(ref3, key2, computed || _core.types.isLiteral(key2)), value2)), prop);
    }
    function buildPublicFieldInitSpec(ref3, prop, state) {
      const {
        key: key2,
        computed
      } = prop.node;
      const value2 = prop.node.value || prop.scope.buildUndefinedNode();
      return inheritPropComments(_core.types.expressionStatement(_core.types.callExpression(state.addHelper("defineProperty"), [ref3, computed || _core.types.isLiteral(key2) ? key2 : _core.types.stringLiteral(key2.name), value2])), prop);
    }
    function buildPrivateStaticMethodInitLoose(ref3, prop, state, privateNamesMap) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        id,
        methodId,
        getId,
        setId,
        initAdded
      } = privateName;
      if (initAdded)
        return;
      const isAccessor = getId || setId;
      if (isAccessor) {
        privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
          initAdded: true
        }));
        return inheritPropComments(_core.template.statement.ast`
        Object.defineProperty(${ref3}, ${id}, {
          // configurable is false by default
          // enumerable is false by default
          // writable is false by default
          get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
          set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
        })
      `, prop);
      }
      return inheritPropComments(_core.template.statement.ast`
      Object.defineProperty(${ref3}, ${id}, {
        // configurable is false by default
        // enumerable is false by default
        // writable is false by default
        value: ${methodId.name}
      });
    `, prop);
    }
    function buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties = false) {
      const privateName = privateNamesMap.get(prop.node.key.id.name);
      const {
        id,
        methodId,
        getId,
        setId,
        getterDeclared,
        setterDeclared,
        static: isStatic
      } = privateName;
      const {
        params,
        body,
        generator,
        async
      } = prop.node;
      const isGetter = getId && !getterDeclared && params.length === 0;
      const isSetter = setId && !setterDeclared && params.length > 0;
      let declId = methodId;
      if (isGetter) {
        privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
          getterDeclared: true
        }));
        declId = getId;
      } else if (isSetter) {
        privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
          setterDeclared: true
        }));
        declId = setId;
      } else if (isStatic && !privateFieldsAsProperties) {
        declId = id;
      }
      return inheritPropComments(_core.types.functionDeclaration(_core.types.cloneNode(declId), params, body, generator, async), prop);
    }
    var thisContextVisitor = _core.traverse.visitors.merge([{
      ThisExpression(path, state) {
        const parent = path.findParent((path2) => !(0, _helperSkipTransparentExpressionWrappers.isTransparentExprWrapper)(path2.node));
        if (_core.types.isUnaryExpression(parent.node, {
          operator: "delete"
        })) {
          path.parentPath.replaceWith(_core.types.booleanLiteral(true));
          return;
        }
        state.needsClassRef = true;
        path.replaceWith(_core.types.cloneNode(state.classRef));
      },
      MetaProperty(path) {
        const meta = path.get("meta");
        const property = path.get("property");
        const {
          scope
        } = path;
        if (meta.isIdentifier({
          name: "new"
        }) && property.isIdentifier({
          name: "target"
        })) {
          path.replaceWith(scope.buildUndefinedNode());
        }
      }
    }, _helperEnvironmentVisitor.default]);
    var innerReferencesVisitor = {
      ReferencedIdentifier(path, state) {
        if (path.scope.bindingIdentifierEquals(path.node.name, state.innerBinding)) {
          state.needsClassRef = true;
          path.node.name = state.classRef.name;
        }
      }
    };
    function replaceThisContext(path, ref3, getSuperRef, file, isStaticBlock, constantSuper, innerBindingRef) {
      var _state$classRef;
      const state = {
        classRef: ref3,
        needsClassRef: false,
        innerBinding: innerBindingRef
      };
      const replacer = new _helperReplaceSupers.default({
        methodPath: path,
        constantSuper,
        file,
        refToPreserve: ref3,
        getSuperRef,
        getObjectRef() {
          state.needsClassRef = true;
          return _core.types.isStaticBlock != null && _core.types.isStaticBlock(path.node) || path.node.static ? ref3 : _core.types.memberExpression(ref3, _core.types.identifier("prototype"));
        }
      });
      replacer.replace();
      if (isStaticBlock || path.isProperty()) {
        path.traverse(thisContextVisitor, state);
      }
      if (innerBindingRef != null && (_state$classRef = state.classRef) != null && _state$classRef.name && state.classRef.name !== (innerBindingRef == null ? void 0 : innerBindingRef.name)) {
        path.traverse(innerReferencesVisitor, state);
      }
      return state.needsClassRef;
    }
    function isNameOrLength({
      key: key2,
      computed
    }) {
      if (key2.type === "Identifier") {
        return !computed && (key2.name === "name" || key2.name === "length");
      }
      if (key2.type === "StringLiteral") {
        return key2.value === "name" || key2.value === "length";
      }
      return false;
    }
    function inheritPropComments(node2, prop) {
      _core.types.inheritLeadingComments(node2, prop.node);
      _core.types.inheritInnerComments(node2, prop.node);
      return node2;
    }
    function buildFieldsInitNodes(ref3, superRef, props, privateNamesMap, state, setPublicClassFields, privateFieldsAsProperties, constantSuper, innerBindingRef) {
      let needsClassRef = false;
      let injectSuperRef;
      const staticNodes = [];
      const instanceNodes = [];
      const pureStaticNodes = [];
      const getSuperRef = _core.types.isIdentifier(superRef) ? () => superRef : () => {
        var _injectSuperRef;
        (_injectSuperRef = injectSuperRef) != null ? _injectSuperRef : injectSuperRef = props[0].scope.generateUidIdentifierBasedOnNode(superRef);
        return injectSuperRef;
      };
      for (const prop of props) {
        prop.isClassProperty() && ts.assertFieldTransformed(prop);
        const isStatic = !(_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node)) && prop.node.static;
        const isInstance = !isStatic;
        const isPrivate = prop.isPrivate();
        const isPublic = !isPrivate;
        const isField = prop.isProperty();
        const isMethod = !isField;
        const isStaticBlock = prop.isStaticBlock == null ? void 0 : prop.isStaticBlock();
        if (isStatic || isMethod && isPrivate || isStaticBlock) {
          const replaced = replaceThisContext(prop, ref3, getSuperRef, state, isStaticBlock, constantSuper, innerBindingRef);
          needsClassRef = needsClassRef || replaced;
        }
        switch (true) {
          case isStaticBlock: {
            const blockBody = prop.node.body;
            if (blockBody.length === 1 && _core.types.isExpressionStatement(blockBody[0])) {
              staticNodes.push(inheritPropComments(blockBody[0], prop));
            } else {
              staticNodes.push(_core.types.inheritsComments(_core.template.statement.ast`(() => { ${blockBody} })()`, prop.node));
            }
            break;
          }
          case (isStatic && isPrivate && isField && privateFieldsAsProperties):
            needsClassRef = true;
            staticNodes.push(buildPrivateFieldInitLoose(_core.types.cloneNode(ref3), prop, privateNamesMap));
            break;
          case (isStatic && isPrivate && isField && !privateFieldsAsProperties):
            needsClassRef = true;
            staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
            break;
          case (isStatic && isPublic && isField && setPublicClassFields):
            if (!isNameOrLength(prop.node)) {
              needsClassRef = true;
              staticNodes.push(buildPublicFieldInitLoose(_core.types.cloneNode(ref3), prop));
              break;
            }
          case (isStatic && isPublic && isField && !setPublicClassFields):
            needsClassRef = true;
            staticNodes.push(buildPublicFieldInitSpec(_core.types.cloneNode(ref3), prop, state));
            break;
          case (isInstance && isPrivate && isField && privateFieldsAsProperties):
            instanceNodes.push(buildPrivateFieldInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
            break;
          case (isInstance && isPrivate && isField && !privateFieldsAsProperties):
            instanceNodes.push(buildPrivateInstanceFieldInitSpec(_core.types.thisExpression(), prop, privateNamesMap, state));
            break;
          case (isInstance && isPrivate && isMethod && privateFieldsAsProperties):
            instanceNodes.unshift(buildPrivateMethodInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
            pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
            break;
          case (isInstance && isPrivate && isMethod && !privateFieldsAsProperties):
            instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(_core.types.thisExpression(), prop, privateNamesMap, state));
            pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
            break;
          case (isStatic && isPrivate && isMethod && !privateFieldsAsProperties):
            needsClassRef = true;
            staticNodes.unshift(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
            pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
            break;
          case (isStatic && isPrivate && isMethod && privateFieldsAsProperties):
            needsClassRef = true;
            staticNodes.unshift(buildPrivateStaticMethodInitLoose(_core.types.cloneNode(ref3), prop, state, privateNamesMap));
            pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
            break;
          case (isInstance && isPublic && isField && setPublicClassFields):
            instanceNodes.push(buildPublicFieldInitLoose(_core.types.thisExpression(), prop));
            break;
          case (isInstance && isPublic && isField && !setPublicClassFields):
            instanceNodes.push(buildPublicFieldInitSpec(_core.types.thisExpression(), prop, state));
            break;
          default:
            throw new Error("Unreachable.");
        }
      }
      return {
        staticNodes: staticNodes.filter(Boolean),
        instanceNodes: instanceNodes.filter(Boolean),
        pureStaticNodes: pureStaticNodes.filter(Boolean),
        wrapClass(path) {
          for (const prop of props) {
            prop.node.leadingComments = null;
            prop.remove();
          }
          if (injectSuperRef) {
            path.scope.push({
              id: _core.types.cloneNode(injectSuperRef)
            });
            path.set("superClass", _core.types.assignmentExpression("=", injectSuperRef, path.node.superClass));
          }
          if (!needsClassRef)
            return path;
          if (path.isClassExpression()) {
            path.scope.push({
              id: ref3
            });
            path.replaceWith(_core.types.assignmentExpression("=", _core.types.cloneNode(ref3), path.node));
          } else if (!path.node.id) {
            path.node.id = ref3;
          }
          return path;
        }
      };
    }
  }
});

// node_modules/@babel/helper-create-class-features-plugin/lib/decorators.js
var require_decorators = __commonJS({
  "node_modules/@babel/helper-create-class-features-plugin/lib/decorators.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.buildDecoratedClass = buildDecoratedClass;
    exports.hasDecorators = hasDecorators;
    exports.hasOwnDecorators = hasOwnDecorators;
    var _core = require_lib32();
    var _helperReplaceSupers = require_lib24();
    var _helperFunctionName = require_lib12();
    function hasOwnDecorators(node2) {
      return !!(node2.decorators && node2.decorators.length);
    }
    function hasDecorators(node2) {
      return hasOwnDecorators(node2) || node2.body.body.some(hasOwnDecorators);
    }
    function prop(key2, value2) {
      if (!value2)
        return null;
      return _core.types.objectProperty(_core.types.identifier(key2), value2);
    }
    function method(key2, body) {
      return _core.types.objectMethod("method", _core.types.identifier(key2), [], _core.types.blockStatement(body));
    }
    function takeDecorators(node2) {
      let result;
      if (node2.decorators && node2.decorators.length > 0) {
        result = _core.types.arrayExpression(node2.decorators.map((decorator) => decorator.expression));
      }
      node2.decorators = void 0;
      return result;
    }
    function getKey(node2) {
      if (node2.computed) {
        return node2.key;
      } else if (_core.types.isIdentifier(node2.key)) {
        return _core.types.stringLiteral(node2.key.name);
      } else {
        return _core.types.stringLiteral(String(node2.key.value));
      }
    }
    function extractElementDescriptor(file, classRef, superRef, path) {
      const isMethod = path.isClassMethod();
      if (path.isPrivate()) {
        throw path.buildCodeFrameError(`Private ${isMethod ? "methods" : "fields"} in decorated classes are not supported yet.`);
      }
      if (path.node.type === "ClassAccessorProperty") {
        throw path.buildCodeFrameError(`Accessor properties are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
      }
      if (path.node.type === "StaticBlock") {
        throw path.buildCodeFrameError(`Static blocks are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
      }
      const {
        node: node2,
        scope
      } = path;
      if (!path.isTSDeclareMethod()) {
        new _helperReplaceSupers.default({
          methodPath: path,
          objectRef: classRef,
          superRef,
          file,
          refToPreserve: classRef
        }).replace();
      }
      const properties = [prop("kind", _core.types.stringLiteral(_core.types.isClassMethod(node2) ? node2.kind : "field")), prop("decorators", takeDecorators(node2)), prop("static", node2.static && _core.types.booleanLiteral(true)), prop("key", getKey(node2))].filter(Boolean);
      if (_core.types.isClassMethod(node2)) {
        const id = node2.computed ? null : node2.key;
        const transformed = _core.types.toExpression(node2);
        properties.push(prop("value", (0, _helperFunctionName.default)({
          node: transformed,
          id,
          scope
        }) || transformed));
      } else if (_core.types.isClassProperty(node2) && node2.value) {
        properties.push(method("value", _core.template.statements.ast`return ${node2.value}`));
      } else {
        properties.push(prop("value", scope.buildUndefinedNode()));
      }
      path.remove();
      return _core.types.objectExpression(properties);
    }
    function addDecorateHelper(file) {
      return file.addHelper("decorate");
    }
    function buildDecoratedClass(ref3, path, elements, file) {
      const {
        node: node2,
        scope
      } = path;
      const initializeId = scope.generateUidIdentifier("initialize");
      const isDeclaration2 = node2.id && path.isDeclaration();
      const isStrict = path.isInStrictMode();
      const {
        superClass
      } = node2;
      node2.type = "ClassDeclaration";
      if (!node2.id)
        node2.id = _core.types.cloneNode(ref3);
      let superId;
      if (superClass) {
        superId = scope.generateUidIdentifierBasedOnNode(node2.superClass, "super");
        node2.superClass = superId;
      }
      const classDecorators = takeDecorators(node2);
      const definitions2 = _core.types.arrayExpression(elements.filter((element2) => !element2.node.abstract && element2.node.type !== "TSIndexSignature").map((path2) => extractElementDescriptor(file, node2.id, superId, path2)));
      const wrapperCall = _core.template.expression.ast`
    ${addDecorateHelper(file)}(
      ${classDecorators || _core.types.nullLiteral()},
      function (${initializeId}, ${superClass ? _core.types.cloneNode(superId) : null}) {
        ${node2}
        return { F: ${_core.types.cloneNode(node2.id)}, d: ${definitions2} };
      },
      ${superClass}
    )
  `;
      if (!isStrict) {
        wrapperCall.arguments[1].body.directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
      }
      let replacement = wrapperCall;
      let classPathDesc = "arguments.1.body.body.0";
      if (isDeclaration2) {
        replacement = _core.template.statement.ast`let ${ref3} = ${wrapperCall}`;
        classPathDesc = "declarations.0.init." + classPathDesc;
      }
      return {
        instanceNodes: [_core.template.statement.ast`${_core.types.cloneNode(initializeId)}(this)`],
        wrapClass(path2) {
          path2.replaceWith(replacement);
          return path2.get(classPathDesc);
        }
      };
    }
  }
});

// node_modules/@babel/helper-create-class-features-plugin/lib/misc.js
var require_misc2 = __commonJS({
  "node_modules/@babel/helper-create-class-features-plugin/lib/misc.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.extractComputedKeys = extractComputedKeys;
    exports.injectInitialization = injectInitialization;
    var _core = require_lib32();
    var _helperEnvironmentVisitor = require_lib6();
    var findBareSupers = _core.traverse.visitors.merge([{
      Super(path) {
        const {
          node: node2,
          parentPath
        } = path;
        if (parentPath.isCallExpression({
          callee: node2
        })) {
          this.push(parentPath);
        }
      }
    }, _helperEnvironmentVisitor.default]);
    var referenceVisitor = {
      "TSTypeAnnotation|TypeAnnotation"(path) {
        path.skip();
      },
      ReferencedIdentifier(path, {
        scope
      }) {
        if (scope.hasOwnBinding(path.node.name)) {
          scope.rename(path.node.name);
          path.skip();
        }
      }
    };
    function handleClassTDZ(path, state) {
      if (state.classBinding && state.classBinding === path.scope.getBinding(path.node.name)) {
        const classNameTDZError = state.file.addHelper("classNameTDZError");
        const throwNode = _core.types.callExpression(classNameTDZError, [_core.types.stringLiteral(path.node.name)]);
        path.replaceWith(_core.types.sequenceExpression([throwNode, path.node]));
        path.skip();
      }
    }
    var classFieldDefinitionEvaluationTDZVisitor = {
      ReferencedIdentifier: handleClassTDZ
    };
    function injectInitialization(path, constructor, nodes, renamer) {
      if (!nodes.length)
        return;
      const isDerived = !!path.node.superClass;
      if (!constructor) {
        const newConstructor = _core.types.classMethod("constructor", _core.types.identifier("constructor"), [], _core.types.blockStatement([]));
        if (isDerived) {
          newConstructor.params = [_core.types.restElement(_core.types.identifier("args"))];
          newConstructor.body.body.push(_core.template.statement.ast`super(...args)`);
        }
        [constructor] = path.get("body").unshiftContainer("body", newConstructor);
      }
      if (renamer) {
        renamer(referenceVisitor, {
          scope: constructor.scope
        });
      }
      if (isDerived) {
        const bareSupers = [];
        constructor.traverse(findBareSupers, bareSupers);
        let isFirst = true;
        for (const bareSuper of bareSupers) {
          if (isFirst) {
            bareSuper.insertAfter(nodes);
            isFirst = false;
          } else {
            bareSuper.insertAfter(nodes.map((n) => _core.types.cloneNode(n)));
          }
        }
      } else {
        constructor.get("body").unshiftContainer("body", nodes);
      }
    }
    function extractComputedKeys(path, computedPaths, file) {
      const declarations = [];
      const state = {
        classBinding: path.node.id && path.scope.getBinding(path.node.id.name),
        file
      };
      for (const computedPath of computedPaths) {
        const computedKey = computedPath.get("key");
        if (computedKey.isReferencedIdentifier()) {
          handleClassTDZ(computedKey, state);
        } else {
          computedKey.traverse(classFieldDefinitionEvaluationTDZVisitor, state);
        }
        const computedNode = computedPath.node;
        if (!computedKey.isConstantExpression()) {
          const ident = path.scope.generateUidIdentifierBasedOnNode(computedNode.key);
          path.scope.push({
            id: ident,
            kind: "let"
          });
          declarations.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(ident), computedNode.key)));
          computedNode.key = _core.types.cloneNode(ident);
        }
      }
      return declarations;
    }
  }
});

// node_modules/@babel/helper-create-class-features-plugin/lib/features.js
var require_features = __commonJS({
  "node_modules/@babel/helper-create-class-features-plugin/lib/features.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.FEATURES = void 0;
    exports.enableFeature = enableFeature;
    exports.isLoose = isLoose;
    exports.shouldTransform = shouldTransform;
    var _decorators = require_decorators();
    var FEATURES = Object.freeze({
      fields: 1 << 1,
      privateMethods: 1 << 2,
      decorators: 1 << 3,
      privateIn: 1 << 4,
      staticBlocks: 1 << 5
    });
    exports.FEATURES = FEATURES;
    var featuresSameLoose = /* @__PURE__ */ new Map([[FEATURES.fields, "@babel/plugin-proposal-class-properties"], [FEATURES.privateMethods, "@babel/plugin-proposal-private-methods"], [FEATURES.privateIn, "@babel/plugin-proposal-private-property-in-object"]]);
    var featuresKey = "@babel/plugin-class-features/featuresKey";
    var looseKey = "@babel/plugin-class-features/looseKey";
    var looseLowPriorityKey = "@babel/plugin-class-features/looseLowPriorityKey/#__internal__@babel/preset-env__please-overwrite-loose-instead-of-throwing";
    function enableFeature(file, feature, loose) {
      if (!hasFeature(file, feature) || canIgnoreLoose(file, feature)) {
        file.set(featuresKey, file.get(featuresKey) | feature);
        if (loose === "#__internal__@babel/preset-env__prefer-true-but-false-is-ok-if-it-prevents-an-error") {
          setLoose(file, feature, true);
          file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);
        } else if (loose === "#__internal__@babel/preset-env__prefer-false-but-true-is-ok-if-it-prevents-an-error") {
          setLoose(file, feature, false);
          file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);
        } else {
          setLoose(file, feature, loose);
        }
      }
      let resolvedLoose;
      let higherPriorityPluginName;
      for (const [mask, name2] of featuresSameLoose) {
        if (!hasFeature(file, mask))
          continue;
        const loose2 = isLoose(file, mask);
        if (canIgnoreLoose(file, mask)) {
          continue;
        } else if (resolvedLoose === !loose2) {
          throw new Error("'loose' mode configuration must be the same for @babel/plugin-proposal-class-properties, @babel/plugin-proposal-private-methods and @babel/plugin-proposal-private-property-in-object (when they are enabled).");
        } else {
          resolvedLoose = loose2;
          higherPriorityPluginName = name2;
        }
      }
      if (resolvedLoose !== void 0) {
        for (const [mask, name2] of featuresSameLoose) {
          if (hasFeature(file, mask) && isLoose(file, mask) !== resolvedLoose) {
            setLoose(file, mask, resolvedLoose);
            console.warn(`Though the "loose" option was set to "${!resolvedLoose}" in your @babel/preset-env config, it will not be used for ${name2} since the "loose" mode option was set to "${resolvedLoose}" for ${higherPriorityPluginName}.
The "loose" option must be the same for @babel/plugin-proposal-class-properties, @babel/plugin-proposal-private-methods and @babel/plugin-proposal-private-property-in-object (when they are enabled): you can silence this warning by explicitly adding
	["${name2}", { "loose": ${resolvedLoose} }]
to the "plugins" section of your Babel config.`);
          }
        }
      }
    }
    function hasFeature(file, feature) {
      return !!(file.get(featuresKey) & feature);
    }
    function isLoose(file, feature) {
      return !!(file.get(looseKey) & feature);
    }
    function setLoose(file, feature, loose) {
      if (loose)
        file.set(looseKey, file.get(looseKey) | feature);
      else
        file.set(looseKey, file.get(looseKey) & ~feature);
      file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) & ~feature);
    }
    function canIgnoreLoose(file, feature) {
      return !!(file.get(looseLowPriorityKey) & feature);
    }
    function shouldTransform(path, file) {
      let decoratorPath = null;
      let publicFieldPath = null;
      let privateFieldPath = null;
      let privateMethodPath = null;
      let staticBlockPath = null;
      if ((0, _decorators.hasOwnDecorators)(path.node)) {
        decoratorPath = path.get("decorators.0");
      }
      for (const el of path.get("body.body")) {
        if (!decoratorPath && (0, _decorators.hasOwnDecorators)(el.node)) {
          decoratorPath = el.get("decorators.0");
        }
        if (!publicFieldPath && el.isClassProperty()) {
          publicFieldPath = el;
        }
        if (!privateFieldPath && el.isClassPrivateProperty()) {
          privateFieldPath = el;
        }
        if (!privateMethodPath && el.isClassPrivateMethod != null && el.isClassPrivateMethod()) {
          privateMethodPath = el;
        }
        if (!staticBlockPath && el.isStaticBlock != null && el.isStaticBlock()) {
          staticBlockPath = el;
        }
      }
      if (decoratorPath && privateFieldPath) {
        throw privateFieldPath.buildCodeFrameError("Private fields in decorated classes are not supported yet.");
      }
      if (decoratorPath && privateMethodPath) {
        throw privateMethodPath.buildCodeFrameError("Private methods in decorated classes are not supported yet.");
      }
      if (decoratorPath && !hasFeature(file, FEATURES.decorators)) {
        throw path.buildCodeFrameError('Decorators are not enabled.\nIf you are using ["@babel/plugin-proposal-decorators", { "version": "legacy" }], make sure it comes *before* "@babel/plugin-proposal-class-properties" and enable loose mode, like so:\n	["@babel/plugin-proposal-decorators", { "version": "legacy" }]\n	["@babel/plugin-proposal-class-properties", { "loose": true }]');
      }
      if (privateMethodPath && !hasFeature(file, FEATURES.privateMethods)) {
        throw privateMethodPath.buildCodeFrameError("Class private methods are not enabled. Please add `@babel/plugin-proposal-private-methods` to your configuration.");
      }
      if ((publicFieldPath || privateFieldPath) && !hasFeature(file, FEATURES.fields) && !hasFeature(file, FEATURES.privateMethods)) {
        throw path.buildCodeFrameError("Class fields are not enabled. Please add `@babel/plugin-proposal-class-properties` to your configuration.");
      }
      if (staticBlockPath && !hasFeature(file, FEATURES.staticBlocks)) {
        throw path.buildCodeFrameError("Static class blocks are not enabled. Please add `@babel/plugin-proposal-class-static-block` to your configuration.");
      }
      if (decoratorPath || privateMethodPath || staticBlockPath) {
        return true;
      }
      if ((publicFieldPath || privateFieldPath) && hasFeature(file, FEATURES.fields)) {
        return true;
      }
      return false;
    }
  }
});

// node_modules/@babel/helper-create-class-features-plugin/lib/index.js
var require_lib27 = __commonJS({
  "node_modules/@babel/helper-create-class-features-plugin/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "FEATURES", {
      enumerable: true,
      get: function() {
        return _features.FEATURES;
      }
    });
    Object.defineProperty(exports, "buildCheckInRHS", {
      enumerable: true,
      get: function() {
        return _fields.buildCheckInRHS;
      }
    });
    exports.createClassFeaturePlugin = createClassFeaturePlugin;
    Object.defineProperty(exports, "enableFeature", {
      enumerable: true,
      get: function() {
        return _features.enableFeature;
      }
    });
    Object.defineProperty(exports, "injectInitialization", {
      enumerable: true,
      get: function() {
        return _misc.injectInitialization;
      }
    });
    var _core = require_lib32();
    var _helperFunctionName = require_lib12();
    var _helperSplitExportDeclaration = require_lib5();
    var _fields = require_fields();
    var _decorators = require_decorators();
    var _misc = require_misc2();
    var _features = require_features();
    var _typescript = require_typescript3();
    var version3 = "7.21.4".split(".").reduce((v, x) => v * 1e5 + +x, 0);
    var versionKey = "@babel/plugin-class-features/version";
    function createClassFeaturePlugin({
      name: name2,
      feature,
      loose,
      manipulateOptions,
      api = {
        assumption: () => void 0
      },
      inherits
    }) {
      const setPublicClassFields = api.assumption("setPublicClassFields");
      const privateFieldsAsSymbols = api.assumption("privateFieldsAsSymbols");
      const privateFieldsAsProperties = api.assumption("privateFieldsAsProperties");
      const constantSuper = api.assumption("constantSuper");
      const noDocumentAll = api.assumption("noDocumentAll");
      if (privateFieldsAsProperties && privateFieldsAsSymbols) {
        throw new Error(`Cannot enable both the "privateFieldsAsProperties" and "privateFieldsAsSymbols" assumptions as the same time.`);
      }
      const privateFieldsAsSymbolsOrProperties = privateFieldsAsProperties || privateFieldsAsSymbols;
      if (loose === true) {
        const explicit = [];
        if (setPublicClassFields !== void 0) {
          explicit.push(`"setPublicClassFields"`);
        }
        if (privateFieldsAsProperties !== void 0) {
          explicit.push(`"privateFieldsAsProperties"`);
        }
        if (privateFieldsAsSymbols !== void 0) {
          explicit.push(`"privateFieldsAsSymbols"`);
        }
        if (explicit.length !== 0) {
          console.warn(`[${name2}]: You are using the "loose: true" option and you are explicitly setting a value for the ${explicit.join(" and ")} assumption${explicit.length > 1 ? "s" : ""}. The "loose" option can cause incompatibilities with the other class features plugins, so it's recommended that you replace it with the following top-level option:
	"assumptions": {
		"setPublicClassFields": true,
		"privateFieldsAsSymbols": true
	}`);
        }
      }
      return {
        name: name2,
        manipulateOptions,
        inherits,
        pre(file) {
          (0, _features.enableFeature)(file, feature, loose);
          if (!file.get(versionKey) || file.get(versionKey) < version3) {
            file.set(versionKey, version3);
          }
        },
        visitor: {
          Class(path, {
            file
          }) {
            if (file.get(versionKey) !== version3)
              return;
            if (!(0, _features.shouldTransform)(path, file))
              return;
            if (path.isClassDeclaration())
              (0, _typescript.assertFieldTransformed)(path);
            const loose2 = (0, _features.isLoose)(file, feature);
            let constructor;
            const isDecorated = (0, _decorators.hasDecorators)(path.node);
            const props = [];
            const elements = [];
            const computedPaths = [];
            const privateNames = /* @__PURE__ */ new Set();
            const body = path.get("body");
            for (const path2 of body.get("body")) {
              if ((path2.isClassProperty() || path2.isClassMethod()) && path2.node.computed) {
                computedPaths.push(path2);
              }
              if (path2.isPrivate()) {
                const {
                  name: name3
                } = path2.node.key.id;
                const getName = `get ${name3}`;
                const setName = `set ${name3}`;
                if (path2.isClassPrivateMethod()) {
                  if (path2.node.kind === "get") {
                    if (privateNames.has(getName) || privateNames.has(name3) && !privateNames.has(setName)) {
                      throw path2.buildCodeFrameError("Duplicate private field");
                    }
                    privateNames.add(getName).add(name3);
                  } else if (path2.node.kind === "set") {
                    if (privateNames.has(setName) || privateNames.has(name3) && !privateNames.has(getName)) {
                      throw path2.buildCodeFrameError("Duplicate private field");
                    }
                    privateNames.add(setName).add(name3);
                  }
                } else {
                  if (privateNames.has(name3) && !privateNames.has(getName) && !privateNames.has(setName) || privateNames.has(name3) && (privateNames.has(getName) || privateNames.has(setName))) {
                    throw path2.buildCodeFrameError("Duplicate private field");
                  }
                  privateNames.add(name3);
                }
              }
              if (path2.isClassMethod({
                kind: "constructor"
              })) {
                constructor = path2;
              } else {
                elements.push(path2);
                if (path2.isProperty() || path2.isPrivate() || path2.isStaticBlock != null && path2.isStaticBlock()) {
                  props.push(path2);
                }
              }
            }
            {
              if (!props.length && !isDecorated)
                return;
            }
            const innerBinding = path.node.id;
            let ref3;
            if (!innerBinding || path.isClassExpression()) {
              (0, _helperFunctionName.default)(path);
              ref3 = path.scope.generateUidIdentifier("class");
            } else {
              ref3 = _core.types.cloneNode(path.node.id);
            }
            const privateNamesMap = (0, _fields.buildPrivateNamesMap)(props);
            const privateNamesNodes = (0, _fields.buildPrivateNamesNodes)(privateNamesMap, privateFieldsAsProperties != null ? privateFieldsAsProperties : loose2, privateFieldsAsSymbols != null ? privateFieldsAsSymbols : false, file);
            (0, _fields.transformPrivateNamesUsage)(ref3, path, privateNamesMap, {
              privateFieldsAsProperties: privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose2,
              noDocumentAll,
              innerBinding
            }, file);
            let keysNodes, staticNodes, instanceNodes, pureStaticNodes, wrapClass;
            {
              if (isDecorated) {
                staticNodes = pureStaticNodes = keysNodes = [];
                ({
                  instanceNodes,
                  wrapClass
                } = (0, _decorators.buildDecoratedClass)(ref3, path, elements, file));
              } else {
                keysNodes = (0, _misc.extractComputedKeys)(path, computedPaths, file);
                ({
                  staticNodes,
                  pureStaticNodes,
                  instanceNodes,
                  wrapClass
                } = (0, _fields.buildFieldsInitNodes)(ref3, path.node.superClass, props, privateNamesMap, file, setPublicClassFields != null ? setPublicClassFields : loose2, privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose2, constantSuper != null ? constantSuper : loose2, innerBinding));
              }
            }
            if (instanceNodes.length > 0) {
              (0, _misc.injectInitialization)(path, constructor, instanceNodes, (referenceVisitor, state) => {
                {
                  if (isDecorated)
                    return;
                }
                for (const prop of props) {
                  if (_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node) || prop.node.static)
                    continue;
                  prop.traverse(referenceVisitor, state);
                }
              });
            }
            const wrappedPath = wrapClass(path);
            wrappedPath.insertBefore([...privateNamesNodes, ...keysNodes]);
            if (staticNodes.length > 0) {
              wrappedPath.insertAfter(staticNodes);
            }
            if (pureStaticNodes.length > 0) {
              wrappedPath.find((parent) => parent.isStatement() || parent.isDeclaration()).insertAfter(pureStaticNodes);
            }
          },
          ExportDefaultDeclaration(path, {
            file
          }) {
            {
              if (file.get(versionKey) !== version3)
                return;
              const decl = path.get("declaration");
              if (decl.isClassDeclaration() && (0, _decorators.hasDecorators)(decl.node)) {
                if (decl.node.id) {
                  (0, _helperSplitExportDeclaration.default)(path);
                } else {
                  decl.node.type = "ClassExpression";
                }
              }
            }
          }
        }
      };
    }
  }
});

// node_modules/@babel/plugin-transform-typescript/lib/enum.js
var require_enum = __commonJS({
  "node_modules/@babel/plugin-transform-typescript/lib/enum.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = transpileEnum;
    exports.translateEnumValues = translateEnumValues;
    var _core = require_lib32();
    var _assert = require("assert");
    var _helperAnnotateAsPure = require_lib25();
    var ENUMS = /* @__PURE__ */ new WeakMap();
    var buildEnumWrapper = _core.template.expression(`
    (function (ID) {
      ASSIGNMENTS;
      return ID;
    })(INIT)
  `);
    function transpileEnum(path, t3) {
      const {
        node: node2,
        parentPath
      } = path;
      if (node2.declare) {
        path.remove();
        return;
      }
      const name2 = node2.id.name;
      const {
        fill,
        data: data3,
        isPure
      } = enumFill(path, t3, node2.id);
      switch (parentPath.type) {
        case "BlockStatement":
        case "ExportNamedDeclaration":
        case "Program": {
          const isGlobal = t3.isProgram(path.parent);
          const isSeen = seen(parentPath);
          let init = t3.objectExpression([]);
          if (isSeen || isGlobal) {
            init = t3.logicalExpression("||", t3.cloneNode(fill.ID), init);
          }
          const enumIIFE = buildEnumWrapper(Object.assign({}, fill, {
            INIT: init
          }));
          if (isPure)
            (0, _helperAnnotateAsPure.default)(enumIIFE);
          if (isSeen) {
            const toReplace = parentPath.isExportDeclaration() ? parentPath : path;
            toReplace.replaceWith(t3.expressionStatement(t3.assignmentExpression("=", t3.cloneNode(node2.id), enumIIFE)));
          } else {
            path.scope.registerDeclaration(path.replaceWith(t3.variableDeclaration(isGlobal ? "var" : "let", [t3.variableDeclarator(node2.id, enumIIFE)]))[0]);
          }
          ENUMS.set(path.scope.getBindingIdentifier(name2), data3);
          break;
        }
        default:
          throw new Error(`Unexpected enum parent '${path.parent.type}`);
      }
      function seen(parentPath2) {
        if (parentPath2.isExportDeclaration()) {
          return seen(parentPath2.parentPath);
        }
        if (parentPath2.getData(name2)) {
          return true;
        } else {
          parentPath2.setData(name2, true);
          return false;
        }
      }
    }
    var buildStringAssignment = (0, _core.template)(`
  ENUM["NAME"] = VALUE;
`);
    var buildNumericAssignment = (0, _core.template)(`
  ENUM[ENUM["NAME"] = VALUE] = "NAME";
`);
    var buildEnumMember = (isString, options) => (isString ? buildStringAssignment : buildNumericAssignment)(options);
    function enumFill(path, t3, id) {
      const {
        enumValues: x,
        data: data3,
        isPure
      } = translateEnumValues(path, t3);
      const assignments = x.map(([memberName, memberValue]) => buildEnumMember(t3.isStringLiteral(memberValue), {
        ENUM: t3.cloneNode(id),
        NAME: memberName,
        VALUE: memberValue
      }));
      return {
        fill: {
          ID: t3.cloneNode(id),
          ASSIGNMENTS: assignments
        },
        data: data3,
        isPure
      };
    }
    function ReferencedIdentifier(expr, state) {
      const {
        seen,
        path,
        t: t3
      } = state;
      const name2 = expr.node.name;
      if (seen.has(name2) && !expr.scope.hasOwnBinding(name2)) {
        expr.replaceWith(t3.memberExpression(t3.cloneNode(path.node.id), t3.cloneNode(expr.node)));
        expr.skip();
      }
    }
    var enumSelfReferenceVisitor = {
      ReferencedIdentifier
    };
    function translateEnumValues(path, t3) {
      const seen = /* @__PURE__ */ new Map();
      let constValue = -1;
      let lastName;
      let isPure = true;
      const enumValues = path.get("members").map((memberPath) => {
        const member = memberPath.node;
        const name2 = t3.isIdentifier(member.id) ? member.id.name : member.id.value;
        const initializerPath = memberPath.get("initializer");
        const initializer = member.initializer;
        let value2;
        if (initializer) {
          constValue = computeConstantValue(initializerPath, seen);
          if (constValue !== void 0) {
            seen.set(name2, constValue);
            if (typeof constValue === "number") {
              value2 = t3.numericLiteral(constValue);
            } else {
              _assert(typeof constValue === "string");
              value2 = t3.stringLiteral(constValue);
            }
          } else {
            isPure && (isPure = initializerPath.isPure());
            if (initializerPath.isReferencedIdentifier()) {
              ReferencedIdentifier(initializerPath, {
                t: t3,
                seen,
                path
              });
            } else {
              initializerPath.traverse(enumSelfReferenceVisitor, {
                t: t3,
                seen,
                path
              });
            }
            value2 = initializerPath.node;
            seen.set(name2, void 0);
          }
        } else if (typeof constValue === "number") {
          constValue += 1;
          value2 = t3.numericLiteral(constValue);
          seen.set(name2, constValue);
        } else if (typeof constValue === "string") {
          throw path.buildCodeFrameError("Enum member must have initializer.");
        } else {
          const lastRef = t3.memberExpression(t3.cloneNode(path.node.id), t3.stringLiteral(lastName), true);
          value2 = t3.binaryExpression("+", t3.numericLiteral(1), lastRef);
          seen.set(name2, void 0);
        }
        lastName = name2;
        return [name2, value2];
      });
      return {
        isPure,
        data: seen,
        enumValues
      };
    }
    function computeConstantValue(path, prevMembers, seen = /* @__PURE__ */ new Set()) {
      return evaluate(path);
      function evaluate(path2) {
        const expr = path2.node;
        switch (expr.type) {
          case "MemberExpression":
            return evaluateRef(path2, prevMembers, seen);
          case "StringLiteral":
            return expr.value;
          case "UnaryExpression":
            return evalUnaryExpression(path2);
          case "BinaryExpression":
            return evalBinaryExpression(path2);
          case "NumericLiteral":
            return expr.value;
          case "ParenthesizedExpression":
            return evaluate(path2.get("expression"));
          case "Identifier":
            return evaluateRef(path2, prevMembers, seen);
          case "TemplateLiteral": {
            if (expr.quasis.length === 1) {
              return expr.quasis[0].value.cooked;
            }
            const paths = path2.get("expressions");
            const quasis = expr.quasis;
            let str = "";
            for (let i = 0; i < quasis.length; i++) {
              str += quasis[i].value.cooked;
              if (i + 1 < quasis.length) {
                const value2 = evaluateRef(paths[i], prevMembers, seen);
                if (value2 === void 0)
                  return void 0;
                str += value2;
              }
            }
            return str;
          }
          default:
            return void 0;
        }
      }
      function evaluateRef(path2, prevMembers2, seen2) {
        if (path2.isMemberExpression()) {
          const expr = path2.node;
          const obj = expr.object;
          const prop = expr.property;
          if (!_core.types.isIdentifier(obj) || (expr.computed ? !_core.types.isStringLiteral(prop) : !_core.types.isIdentifier(prop))) {
            return;
          }
          const bindingIdentifier = path2.scope.getBindingIdentifier(obj.name);
          const data3 = ENUMS.get(bindingIdentifier);
          if (!data3)
            return;
          return data3.get(prop.computed ? prop.value : prop.name);
        } else if (path2.isIdentifier()) {
          const name2 = path2.node.name;
          let value2 = prevMembers2 == null ? void 0 : prevMembers2.get(name2);
          if (value2 !== void 0) {
            return value2;
          }
          if (seen2.has(path2.node))
            return;
          const bindingInitPath = path2.resolve();
          if (bindingInitPath) {
            seen2.add(path2.node);
            value2 = computeConstantValue(bindingInitPath, void 0, seen2);
            prevMembers2 == null ? void 0 : prevMembers2.set(name2, value2);
            return value2;
          }
        }
      }
      function evalUnaryExpression(path2) {
        const value2 = evaluate(path2.get("argument"));
        if (value2 === void 0) {
          return void 0;
        }
        switch (path2.node.operator) {
          case "+":
            return value2;
          case "-":
            return -value2;
          case "~":
            return ~value2;
          default:
            return void 0;
        }
      }
      function evalBinaryExpression(path2) {
        const left = evaluate(path2.get("left"));
        if (left === void 0) {
          return void 0;
        }
        const right = evaluate(path2.get("right"));
        if (right === void 0) {
          return void 0;
        }
        switch (path2.node.operator) {
          case "|":
            return left | right;
          case "&":
            return left & right;
          case ">>":
            return left >> right;
          case ">>>":
            return left >>> right;
          case "<<":
            return left << right;
          case "^":
            return left ^ right;
          case "*":
            return left * right;
          case "/":
            return left / right;
          case "+":
            return left + right;
          case "-":
            return left - right;
          case "%":
            return left % right;
          case "**":
            return Math.pow(left, right);
          default:
            return void 0;
        }
      }
    }
  }
});

// node_modules/@babel/plugin-transform-typescript/lib/const-enum.js
var require_const_enum = __commonJS({
  "node_modules/@babel/plugin-transform-typescript/lib/const-enum.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = transpileConstEnum;
    var _enum = require_enum();
    function transpileConstEnum(path, t3) {
      const {
        name: name2
      } = path.node.id;
      const parentIsExport = path.parentPath.isExportNamedDeclaration();
      let isExported = parentIsExport;
      if (!isExported && t3.isProgram(path.parent)) {
        isExported = path.parent.body.some((stmt) => t3.isExportNamedDeclaration(stmt) && stmt.exportKind !== "type" && !stmt.source && stmt.specifiers.some((spec) => t3.isExportSpecifier(spec) && spec.exportKind !== "type" && spec.local.name === name2));
      }
      const {
        enumValues: entries
      } = (0, _enum.translateEnumValues)(path, t3);
      if (isExported) {
        const obj = t3.objectExpression(entries.map(([name3, value2]) => t3.objectProperty(t3.isValidIdentifier(name3) ? t3.identifier(name3) : t3.stringLiteral(name3), value2)));
        if (path.scope.hasOwnBinding(name2)) {
          (parentIsExport ? path.parentPath : path).replaceWith(t3.expressionStatement(t3.callExpression(t3.memberExpression(t3.identifier("Object"), t3.identifier("assign")), [path.node.id, obj])));
        } else {
          path.replaceWith(t3.variableDeclaration("var", [t3.variableDeclarator(path.node.id, obj)]));
          path.scope.registerDeclaration(path);
        }
        return;
      }
      const entriesMap = new Map(entries);
      path.scope.path.traverse({
        Scope(path2) {
          if (path2.scope.hasOwnBinding(name2))
            path2.skip();
        },
        MemberExpression(path2) {
          if (!t3.isIdentifier(path2.node.object, {
            name: name2
          }))
            return;
          let key2;
          if (path2.node.computed) {
            if (t3.isStringLiteral(path2.node.property)) {
              key2 = path2.node.property.value;
            } else {
              return;
            }
          } else if (t3.isIdentifier(path2.node.property)) {
            key2 = path2.node.property.name;
          } else {
            return;
          }
          if (!entriesMap.has(key2))
            return;
          path2.replaceWith(t3.cloneNode(entriesMap.get(key2)));
        }
      });
      path.remove();
    }
  }
});

// node_modules/@babel/plugin-transform-typescript/lib/namespace.js
var require_namespace = __commonJS({
  "node_modules/@babel/plugin-transform-typescript/lib/namespace.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = transpileNamespace;
    var _core = require_lib32();
    function transpileNamespace(path, allowNamespaces) {
      if (path.node.declare || path.node.id.type === "StringLiteral") {
        path.remove();
        return;
      }
      if (!allowNamespaces) {
        throw path.get("id").buildCodeFrameError("Namespace not marked type-only declare. Non-declarative namespaces are only supported experimentally in Babel. To enable and review caveats see: https://babeljs.io/docs/en/babel-plugin-transform-typescript");
      }
      const name2 = path.node.id.name;
      const value2 = handleNested(path, _core.types.cloneNode(path.node, true));
      const bound = path.scope.hasOwnBinding(name2);
      if (path.parent.type === "ExportNamedDeclaration") {
        if (!bound) {
          path.parentPath.insertAfter(value2);
          path.replaceWith(getDeclaration(name2));
          path.scope.registerDeclaration(path.parentPath);
        } else {
          path.parentPath.replaceWith(value2);
        }
      } else if (bound) {
        path.replaceWith(value2);
      } else {
        path.scope.registerDeclaration(path.replaceWithMultiple([getDeclaration(name2), value2])[0]);
      }
    }
    function getDeclaration(name2) {
      return _core.types.variableDeclaration("let", [_core.types.variableDeclarator(_core.types.identifier(name2))]);
    }
    function getMemberExpression(name2, itemName) {
      return _core.types.memberExpression(_core.types.identifier(name2), _core.types.identifier(itemName));
    }
    function handleVariableDeclaration(node2, name2, hub) {
      if (node2.kind !== "const") {
        throw hub.file.buildCodeFrameError(node2, "Namespaces exporting non-const are not supported by Babel. Change to const or see: https://babeljs.io/docs/en/babel-plugin-transform-typescript");
      }
      const {
        declarations
      } = node2;
      if (declarations.every((declarator) => _core.types.isIdentifier(declarator.id))) {
        for (const declarator of declarations) {
          declarator.init = _core.types.assignmentExpression("=", getMemberExpression(name2, declarator.id.name), declarator.init);
        }
        return [node2];
      }
      const bindingIdentifiers = _core.types.getBindingIdentifiers(node2);
      const assignments = [];
      for (const idName in bindingIdentifiers) {
        assignments.push(_core.types.assignmentExpression("=", getMemberExpression(name2, idName), _core.types.cloneNode(bindingIdentifiers[idName])));
      }
      return [node2, _core.types.expressionStatement(_core.types.sequenceExpression(assignments))];
    }
    function buildNestedAmbientModuleError(path, node2) {
      return path.hub.buildError(node2, "Ambient modules cannot be nested in other modules or namespaces.", Error);
    }
    function handleNested(path, node2, parentExport) {
      const names = /* @__PURE__ */ new Set();
      const realName = node2.id;
      _core.types.assertIdentifier(realName);
      const name2 = path.scope.generateUid(realName.name);
      const namespaceTopLevel = _core.types.isTSModuleBlock(node2.body) ? node2.body.body : [_core.types.exportNamedDeclaration(node2.body)];
      for (let i = 0; i < namespaceTopLevel.length; i++) {
        const subNode = namespaceTopLevel[i];
        switch (subNode.type) {
          case "TSModuleDeclaration": {
            if (!_core.types.isIdentifier(subNode.id)) {
              throw buildNestedAmbientModuleError(path, subNode);
            }
            const transformed = handleNested(path, subNode);
            const moduleName = subNode.id.name;
            if (names.has(moduleName)) {
              namespaceTopLevel[i] = transformed;
            } else {
              names.add(moduleName);
              namespaceTopLevel.splice(i++, 1, getDeclaration(moduleName), transformed);
            }
            continue;
          }
          case "TSEnumDeclaration":
          case "FunctionDeclaration":
          case "ClassDeclaration":
            names.add(subNode.id.name);
            continue;
          case "VariableDeclaration": {
            for (const name3 in _core.types.getBindingIdentifiers(subNode)) {
              names.add(name3);
            }
            continue;
          }
          default:
            continue;
          case "ExportNamedDeclaration":
        }
        if ("declare" in subNode.declaration && subNode.declaration.declare) {
          continue;
        }
        switch (subNode.declaration.type) {
          case "TSEnumDeclaration":
          case "FunctionDeclaration":
          case "ClassDeclaration": {
            const itemName = subNode.declaration.id.name;
            names.add(itemName);
            namespaceTopLevel.splice(i++, 1, subNode.declaration, _core.types.expressionStatement(_core.types.assignmentExpression("=", getMemberExpression(name2, itemName), _core.types.identifier(itemName))));
            break;
          }
          case "VariableDeclaration": {
            const nodes = handleVariableDeclaration(subNode.declaration, name2, path.hub);
            namespaceTopLevel.splice(i, nodes.length, ...nodes);
            i += nodes.length - 1;
            break;
          }
          case "TSModuleDeclaration": {
            if (!_core.types.isIdentifier(subNode.declaration.id)) {
              throw buildNestedAmbientModuleError(path, subNode.declaration);
            }
            const transformed = handleNested(path, subNode.declaration, _core.types.identifier(name2));
            const moduleName = subNode.declaration.id.name;
            if (names.has(moduleName)) {
              namespaceTopLevel[i] = transformed;
            } else {
              names.add(moduleName);
              namespaceTopLevel.splice(i++, 1, getDeclaration(moduleName), transformed);
            }
          }
        }
      }
      let fallthroughValue = _core.types.objectExpression([]);
      if (parentExport) {
        const memberExpr = _core.types.memberExpression(parentExport, realName);
        fallthroughValue = _core.template.expression.ast`
      ${_core.types.cloneNode(memberExpr)} ||
        (${_core.types.cloneNode(memberExpr)} = ${fallthroughValue})
    `;
      }
      return _core.template.statement.ast`
    (function (${_core.types.identifier(name2)}) {
      ${namespaceTopLevel}
    })(${realName} || (${_core.types.cloneNode(realName)} = ${fallthroughValue}));
  `;
    }
  }
});

// node_modules/@babel/plugin-transform-typescript/lib/index.js
var require_lib28 = __commonJS({
  "node_modules/@babel/plugin-transform-typescript/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperPluginUtils = require_lib20();
    var _pluginSyntaxTypescript = require_lib21();
    var _helperCreateClassFeaturesPlugin = require_lib27();
    var _constEnum = require_const_enum();
    var _enum = require_enum();
    var _namespace = require_namespace();
    function isInType(path) {
      switch (path.parent.type) {
        case "TSTypeReference":
        case "TSExpressionWithTypeArguments":
        case "TSTypeQuery":
          return true;
        case "TSQualifiedName":
          return path.parentPath.findParent((path2) => path2.type !== "TSQualifiedName").type !== "TSImportEqualsDeclaration";
        case "ExportSpecifier":
          return path.parent.exportKind === "type" || path.parentPath.parent.exportKind === "type";
        default:
          return false;
      }
    }
    var GLOBAL_TYPES = /* @__PURE__ */ new WeakMap();
    var NEEDS_EXPLICIT_ESM = /* @__PURE__ */ new WeakMap();
    var PARSED_PARAMS = /* @__PURE__ */ new WeakSet();
    function isGlobalType({
      scope
    }, name2) {
      if (scope.hasBinding(name2))
        return false;
      if (GLOBAL_TYPES.get(scope).has(name2))
        return true;
      console.warn(`The exported identifier "${name2}" is not declared in Babel's scope tracker
as a JavaScript value binding, and "@babel/plugin-transform-typescript"
never encountered it as a TypeScript type declaration.
It will be treated as a JavaScript value.

This problem is likely caused by another plugin injecting
"${name2}" without registering it in the scope tracker. If you are the author
 of that plugin, please use "scope.registerDeclaration(declarationPath)".`);
      return false;
    }
    function registerGlobalType(programScope, name2) {
      GLOBAL_TYPES.get(programScope).add(name2);
    }
    function safeRemove(path) {
      const ids = path.getBindingIdentifiers();
      for (const name2 of Object.keys(ids)) {
        const binding = path.scope.getBinding(name2);
        if (binding && binding.identifier === ids[name2]) {
          binding.scope.removeBinding(name2);
        }
      }
      path.opts.noScope = true;
      path.remove();
      path.opts.noScope = false;
    }
    var _default = (0, _helperPluginUtils.declare)((api, opts) => {
      const {
        types: t3,
        template
      } = api;
      api.assertVersion(7);
      const JSX_PRAGMA_REGEX = /\*?\s*@jsx((?:Frag)?)\s+([^\s]+)/;
      const {
        allowNamespaces = true,
        jsxPragma = "React.createElement",
        jsxPragmaFrag = "React.Fragment",
        onlyRemoveTypeImports = false,
        optimizeConstEnums = false
      } = opts;
      {
        var {
          allowDeclareFields = false
        } = opts;
      }
      const classMemberVisitors = {
        field(path) {
          const {
            node: node2
          } = path;
          {
            if (!allowDeclareFields && node2.declare) {
              throw path.buildCodeFrameError(`The 'declare' modifier is only allowed when the 'allowDeclareFields' option of @babel/plugin-transform-typescript or @babel/preset-typescript is enabled.`);
            }
          }
          if (node2.declare) {
            if (node2.value) {
              throw path.buildCodeFrameError(`Fields with the 'declare' modifier cannot be initialized here, but only in the constructor`);
            }
            if (!node2.decorators) {
              path.remove();
            }
          } else if (node2.definite) {
            if (node2.value) {
              throw path.buildCodeFrameError(`Definitely assigned fields cannot be initialized here, but only in the constructor`);
            }
            {
              if (!allowDeclareFields && !node2.decorators && !t3.isClassPrivateProperty(node2)) {
                path.remove();
              }
            }
          } else if (node2.abstract) {
            path.remove();
          } else {
            if (!allowDeclareFields && !node2.value && !node2.decorators && !t3.isClassPrivateProperty(node2)) {
              path.remove();
            }
          }
          if (node2.accessibility)
            node2.accessibility = null;
          if (node2.abstract)
            node2.abstract = null;
          if (node2.readonly)
            node2.readonly = null;
          if (node2.optional)
            node2.optional = null;
          if (node2.typeAnnotation)
            node2.typeAnnotation = null;
          if (node2.definite)
            node2.definite = null;
          if (node2.declare)
            node2.declare = null;
          if (node2.override)
            node2.override = null;
        },
        method({
          node: node2
        }) {
          if (node2.accessibility)
            node2.accessibility = null;
          if (node2.abstract)
            node2.abstract = null;
          if (node2.optional)
            node2.optional = null;
          if (node2.override)
            node2.override = null;
        },
        constructor(path, classPath) {
          if (path.node.accessibility)
            path.node.accessibility = null;
          const assigns = [];
          const {
            scope
          } = path;
          for (const paramPath of path.get("params")) {
            const param = paramPath.node;
            if (param.type === "TSParameterProperty") {
              const parameter = param.parameter;
              if (PARSED_PARAMS.has(parameter))
                continue;
              PARSED_PARAMS.add(parameter);
              let id;
              if (t3.isIdentifier(parameter)) {
                id = parameter;
              } else if (t3.isAssignmentPattern(parameter) && t3.isIdentifier(parameter.left)) {
                id = parameter.left;
              } else {
                throw paramPath.buildCodeFrameError("Parameter properties can not be destructuring patterns.");
              }
              assigns.push(template.statement.ast`
          this.${t3.cloneNode(id)} = ${t3.cloneNode(id)}`);
              paramPath.replaceWith(paramPath.get("parameter"));
              scope.registerBinding("param", paramPath);
            }
          }
          (0, _helperCreateClassFeaturesPlugin.injectInitialization)(classPath, path, assigns);
        }
      };
      return {
        name: "transform-typescript",
        inherits: _pluginSyntaxTypescript.default,
        visitor: {
          Pattern: visitPattern,
          Identifier: visitPattern,
          RestElement: visitPattern,
          Program: {
            enter(path, state) {
              const {
                file
              } = state;
              let fileJsxPragma = null;
              let fileJsxPragmaFrag = null;
              const programScope = path.scope;
              if (!GLOBAL_TYPES.has(programScope)) {
                GLOBAL_TYPES.set(programScope, /* @__PURE__ */ new Set());
              }
              if (file.ast.comments) {
                for (const comment2 of file.ast.comments) {
                  const jsxMatches = JSX_PRAGMA_REGEX.exec(comment2.value);
                  if (jsxMatches) {
                    if (jsxMatches[1]) {
                      fileJsxPragmaFrag = jsxMatches[2];
                    } else {
                      fileJsxPragma = jsxMatches[2];
                    }
                  }
                }
              }
              let pragmaImportName = fileJsxPragma || jsxPragma;
              if (pragmaImportName) {
                [pragmaImportName] = pragmaImportName.split(".");
              }
              let pragmaFragImportName = fileJsxPragmaFrag || jsxPragmaFrag;
              if (pragmaFragImportName) {
                [pragmaFragImportName] = pragmaFragImportName.split(".");
              }
              for (let stmt of path.get("body")) {
                if (stmt.isImportDeclaration()) {
                  if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) {
                    NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
                  }
                  if (stmt.node.importKind === "type") {
                    for (const specifier of stmt.node.specifiers) {
                      registerGlobalType(programScope, specifier.local.name);
                    }
                    stmt.remove();
                    continue;
                  }
                  const importsToRemove = /* @__PURE__ */ new Set();
                  const specifiersLength = stmt.node.specifiers.length;
                  const isAllSpecifiersElided = () => specifiersLength > 0 && specifiersLength === importsToRemove.size;
                  for (const specifier of stmt.node.specifiers) {
                    if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") {
                      registerGlobalType(programScope, specifier.local.name);
                      const binding = stmt.scope.getBinding(specifier.local.name);
                      if (binding) {
                        importsToRemove.add(binding.path);
                      }
                    }
                  }
                  if (onlyRemoveTypeImports) {
                    NEEDS_EXPLICIT_ESM.set(path.node, false);
                  } else {
                    if (stmt.node.specifiers.length === 0) {
                      NEEDS_EXPLICIT_ESM.set(path.node, false);
                      continue;
                    }
                    for (const specifier of stmt.node.specifiers) {
                      const binding = stmt.scope.getBinding(specifier.local.name);
                      if (binding && !importsToRemove.has(binding.path)) {
                        if (isImportTypeOnly({
                          binding,
                          programPath: path,
                          pragmaImportName,
                          pragmaFragImportName
                        })) {
                          importsToRemove.add(binding.path);
                        } else {
                          NEEDS_EXPLICIT_ESM.set(path.node, false);
                        }
                      }
                    }
                  }
                  if (isAllSpecifiersElided() && !onlyRemoveTypeImports) {
                    stmt.remove();
                  } else {
                    for (const importPath of importsToRemove) {
                      importPath.remove();
                    }
                  }
                  continue;
                }
                if (stmt.isExportDeclaration()) {
                  stmt = stmt.get("declaration");
                }
                if (stmt.isVariableDeclaration({
                  declare: true
                })) {
                  for (const name2 of Object.keys(stmt.getBindingIdentifiers())) {
                    registerGlobalType(programScope, name2);
                  }
                } else if (stmt.isTSTypeAliasDeclaration() || stmt.isTSDeclareFunction() && stmt.get("id").isIdentifier() || stmt.isTSInterfaceDeclaration() || stmt.isClassDeclaration({
                  declare: true
                }) || stmt.isTSEnumDeclaration({
                  declare: true
                }) || stmt.isTSModuleDeclaration({
                  declare: true
                }) && stmt.get("id").isIdentifier()) {
                  registerGlobalType(programScope, stmt.node.id.name);
                }
              }
            },
            exit(path) {
              if (path.node.sourceType === "module" && NEEDS_EXPLICIT_ESM.get(path.node)) {
                path.pushContainer("body", t3.exportNamedDeclaration());
              }
            }
          },
          ExportNamedDeclaration(path, state) {
            if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) {
              NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
            }
            if (path.node.exportKind === "type") {
              path.remove();
              return;
            }
            if (path.node.source && path.node.specifiers.length > 0 && path.node.specifiers.every((specifier) => specifier.type === "ExportSpecifier" && specifier.exportKind === "type")) {
              path.remove();
              return;
            }
            if (!path.node.source && path.node.specifiers.length > 0 && path.node.specifiers.every((specifier) => t3.isExportSpecifier(specifier) && isGlobalType(path, specifier.local.name))) {
              path.remove();
              return;
            }
            NEEDS_EXPLICIT_ESM.set(state.file.ast.program, false);
          },
          ExportAllDeclaration(path) {
            if (path.node.exportKind === "type")
              path.remove();
          },
          ExportSpecifier(path) {
            const parent = path.parent;
            if (!parent.source && isGlobalType(path, path.node.local.name) || path.node.exportKind === "type") {
              path.remove();
            }
          },
          ExportDefaultDeclaration(path, state) {
            if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) {
              NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
            }
            if (t3.isIdentifier(path.node.declaration) && isGlobalType(path, path.node.declaration.name)) {
              path.remove();
              return;
            }
            NEEDS_EXPLICIT_ESM.set(state.file.ast.program, false);
          },
          TSDeclareFunction(path) {
            safeRemove(path);
          },
          TSDeclareMethod(path) {
            safeRemove(path);
          },
          VariableDeclaration(path) {
            if (path.node.declare) {
              safeRemove(path);
            }
          },
          VariableDeclarator({
            node: node2
          }) {
            if (node2.definite)
              node2.definite = null;
          },
          TSIndexSignature(path) {
            path.remove();
          },
          ClassDeclaration(path) {
            const {
              node: node2
            } = path;
            if (node2.declare) {
              safeRemove(path);
            }
          },
          Class(path) {
            const {
              node: node2
            } = path;
            if (node2.typeParameters)
              node2.typeParameters = null;
            if (node2.superTypeParameters)
              node2.superTypeParameters = null;
            if (node2.implements)
              node2.implements = null;
            if (node2.abstract)
              node2.abstract = null;
            path.get("body.body").forEach((child) => {
              if (child.isClassMethod() || child.isClassPrivateMethod()) {
                if (child.node.kind === "constructor") {
                  classMemberVisitors.constructor(child, path);
                } else {
                  classMemberVisitors.method(child);
                }
              } else if (child.isClassProperty() || child.isClassPrivateProperty() || child.isClassAccessorProperty()) {
                classMemberVisitors.field(child);
              }
            });
          },
          Function(path) {
            const {
              node: node2
            } = path;
            if (node2.typeParameters)
              node2.typeParameters = null;
            if (node2.returnType)
              node2.returnType = null;
            const params = node2.params;
            if (params.length > 0 && t3.isIdentifier(params[0], {
              name: "this"
            })) {
              params.shift();
            }
          },
          TSModuleDeclaration(path) {
            (0, _namespace.default)(path, allowNamespaces);
          },
          TSInterfaceDeclaration(path) {
            path.remove();
          },
          TSTypeAliasDeclaration(path) {
            path.remove();
          },
          TSEnumDeclaration(path) {
            if (optimizeConstEnums && path.node.const) {
              (0, _constEnum.default)(path, t3);
            } else {
              (0, _enum.default)(path, t3);
            }
          },
          TSImportEqualsDeclaration(path) {
            if (t3.isTSExternalModuleReference(path.node.moduleReference)) {
              throw path.buildCodeFrameError(`\`import ${path.node.id.name} = require('${path.node.moduleReference.expression.value}')\` is not supported by @babel/plugin-transform-typescript
Please consider using \`import ${path.node.id.name} from '${path.node.moduleReference.expression.value}';\` alongside Typescript's --allowSyntheticDefaultImports option.`);
            }
            path.replaceWith(t3.variableDeclaration("var", [t3.variableDeclarator(path.node.id, entityNameToExpr(path.node.moduleReference))]));
            path.scope.registerDeclaration(path);
          },
          TSExportAssignment(path) {
            throw path.buildCodeFrameError("`export =` is not supported by @babel/plugin-transform-typescript\nPlease consider using `export <value>;`.");
          },
          TSTypeAssertion(path) {
            path.replaceWith(path.node.expression);
          },
          [`TSAsExpression${t3.tsSatisfiesExpression ? "|TSSatisfiesExpression" : ""}`](path) {
            let {
              node: node2
            } = path;
            do {
              node2 = node2.expression;
            } while (t3.isTSAsExpression(node2) || t3.isTSSatisfiesExpression != null && t3.isTSSatisfiesExpression(node2));
            path.replaceWith(node2);
          },
          [api.types.tsInstantiationExpression ? "TSNonNullExpression|TSInstantiationExpression" : "TSNonNullExpression"](path) {
            path.replaceWith(path.node.expression);
          },
          CallExpression(path) {
            path.node.typeParameters = null;
          },
          OptionalCallExpression(path) {
            path.node.typeParameters = null;
          },
          NewExpression(path) {
            path.node.typeParameters = null;
          },
          JSXOpeningElement(path) {
            path.node.typeParameters = null;
          },
          TaggedTemplateExpression(path) {
            path.node.typeParameters = null;
          }
        }
      };
      function entityNameToExpr(node2) {
        if (t3.isTSQualifiedName(node2)) {
          return t3.memberExpression(entityNameToExpr(node2.left), node2.right);
        }
        return node2;
      }
      function visitPattern({
        node: node2
      }) {
        if (node2.typeAnnotation)
          node2.typeAnnotation = null;
        if (t3.isIdentifier(node2) && node2.optional)
          node2.optional = null;
      }
      function isImportTypeOnly({
        binding,
        programPath,
        pragmaImportName,
        pragmaFragImportName
      }) {
        for (const path of binding.referencePaths) {
          if (!isInType(path)) {
            return false;
          }
        }
        if (binding.identifier.name !== pragmaImportName && binding.identifier.name !== pragmaFragImportName) {
          return true;
        }
        let sourceFileHasJsx = false;
        programPath.traverse({
          "JSXElement|JSXFragment"(path) {
            sourceFileHasJsx = true;
            path.stop();
          }
        });
        return !sourceFileHasJsx;
      }
    });
    exports.default = _default;
  }
});

// node_modules/@babel/plugin-syntax-jsx/lib/index.js
var require_lib29 = __commonJS({
  "node_modules/@babel/plugin-syntax-jsx/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperPluginUtils = require_lib20();
    var _default = (0, _helperPluginUtils.declare)((api) => {
      api.assertVersion(7);
      return {
        name: "syntax-jsx",
        manipulateOptions(opts, parserOpts) {
          {
            if (parserOpts.plugins.some((p) => (Array.isArray(p) ? p[0] : p) === "typescript")) {
              return;
            }
          }
          parserOpts.plugins.push("jsx");
        }
      };
    });
    exports.default = _default;
  }
});

// node_modules/@babel/plugin-transform-modules-commonjs/lib/dynamic-import.js
var require_dynamic_import2 = __commonJS({
  "node_modules/@babel/plugin-transform-modules-commonjs/lib/dynamic-import.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.transformDynamicImport = transformDynamicImport;
    var _core = require_lib32();
    var _helperModuleTransforms = require_lib17();
    var requireNoInterop = (source2) => _core.template.expression.ast`require(${source2})`;
    var requireInterop = (source2, file) => _core.types.callExpression(file.addHelper("interopRequireWildcard"), [requireNoInterop(source2)]);
    function transformDynamicImport(path, noInterop, file) {
      const buildRequire = noInterop ? requireNoInterop : requireInterop;
      path.replaceWith((0, _helperModuleTransforms.buildDynamicImport)(path.node, true, false, (specifier) => buildRequire(specifier, file)));
    }
  }
});

// node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js
var require_lib30 = __commonJS({
  "node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperPluginUtils = require_lib20();
    var _helperModuleTransforms = require_lib17();
    var _helperSimpleAccess = require_lib16();
    var _core = require_lib32();
    var _dynamicImport = require_dynamic_import2();
    var _default = (0, _helperPluginUtils.declare)((api, options) => {
      var _api$assumption, _api$assumption2, _api$assumption3;
      api.assertVersion(7);
      const {
        strictNamespace = false,
        mjsStrictNamespace = strictNamespace,
        allowTopLevelThis,
        strict,
        strictMode,
        noInterop,
        importInterop,
        lazy = false,
        allowCommonJSExports = true,
        loose = false
      } = options;
      const constantReexports = (_api$assumption = api.assumption("constantReexports")) != null ? _api$assumption : loose;
      const enumerableModuleMeta = (_api$assumption2 = api.assumption("enumerableModuleMeta")) != null ? _api$assumption2 : loose;
      const noIncompleteNsImportDetection = (_api$assumption3 = api.assumption("noIncompleteNsImportDetection")) != null ? _api$assumption3 : false;
      if (typeof lazy !== "boolean" && typeof lazy !== "function" && (!Array.isArray(lazy) || !lazy.every((item) => typeof item === "string"))) {
        throw new Error(`.lazy must be a boolean, array of strings, or a function`);
      }
      if (typeof strictNamespace !== "boolean") {
        throw new Error(`.strictNamespace must be a boolean, or undefined`);
      }
      if (typeof mjsStrictNamespace !== "boolean") {
        throw new Error(`.mjsStrictNamespace must be a boolean, or undefined`);
      }
      const getAssertion = (localName) => _core.template.expression.ast`
    (function(){
      throw new Error(
        "The CommonJS '" + "${localName}" + "' variable is not available in ES6 modules." +
        "Consider setting setting sourceType:script or sourceType:unambiguous in your " +
        "Babel config for this file.");
    })()
  `;
      const moduleExportsVisitor = {
        ReferencedIdentifier(path) {
          const localName = path.node.name;
          if (localName !== "module" && localName !== "exports")
            return;
          const localBinding = path.scope.getBinding(localName);
          const rootBinding = this.scope.getBinding(localName);
          if (rootBinding !== localBinding || path.parentPath.isObjectProperty({
            value: path.node
          }) && path.parentPath.parentPath.isObjectPattern() || path.parentPath.isAssignmentExpression({
            left: path.node
          }) || path.isAssignmentExpression({
            left: path.node
          })) {
            return;
          }
          path.replaceWith(getAssertion(localName));
        },
        UpdateExpression(path) {
          const arg = path.get("argument");
          if (!arg.isIdentifier())
            return;
          const localName = arg.node.name;
          if (localName !== "module" && localName !== "exports")
            return;
          const localBinding = path.scope.getBinding(localName);
          const rootBinding = this.scope.getBinding(localName);
          if (rootBinding !== localBinding)
            return;
          path.replaceWith(_core.types.assignmentExpression(path.node.operator[0] + "=", arg.node, getAssertion(localName)));
        },
        AssignmentExpression(path) {
          const left = path.get("left");
          if (left.isIdentifier()) {
            const localName = left.node.name;
            if (localName !== "module" && localName !== "exports")
              return;
            const localBinding = path.scope.getBinding(localName);
            const rootBinding = this.scope.getBinding(localName);
            if (rootBinding !== localBinding)
              return;
            const right = path.get("right");
            right.replaceWith(_core.types.sequenceExpression([right.node, getAssertion(localName)]));
          } else if (left.isPattern()) {
            const ids = left.getOuterBindingIdentifiers();
            const localName = Object.keys(ids).filter((localName2) => {
              if (localName2 !== "module" && localName2 !== "exports")
                return false;
              return this.scope.getBinding(localName2) === path.scope.getBinding(localName2);
            })[0];
            if (localName) {
              const right = path.get("right");
              right.replaceWith(_core.types.sequenceExpression([right.node, getAssertion(localName)]));
            }
          }
        }
      };
      return {
        name: "transform-modules-commonjs",
        pre() {
          this.file.set("@babel/plugin-transform-modules-*", "commonjs");
        },
        visitor: {
          CallExpression(path) {
            if (!this.file.has("@babel/plugin-proposal-dynamic-import"))
              return;
            if (!_core.types.isImport(path.node.callee))
              return;
            let {
              scope
            } = path;
            do {
              scope.rename("require");
            } while (scope = scope.parent);
            (0, _dynamicImport.transformDynamicImport)(path, noInterop, this.file);
          },
          Program: {
            exit(path, state) {
              if (!(0, _helperModuleTransforms.isModule)(path))
                return;
              path.scope.rename("exports");
              path.scope.rename("module");
              path.scope.rename("require");
              path.scope.rename("__filename");
              path.scope.rename("__dirname");
              if (!allowCommonJSExports) {
                (0, _helperSimpleAccess.default)(path, /* @__PURE__ */ new Set(["module", "exports"]), false);
                path.traverse(moduleExportsVisitor, {
                  scope: path.scope
                });
              }
              let moduleName = (0, _helperModuleTransforms.getModuleName)(this.file.opts, options);
              if (moduleName)
                moduleName = _core.types.stringLiteral(moduleName);
              const {
                meta,
                headers
              } = (0, _helperModuleTransforms.rewriteModuleStatementsAndPrepareHeader)(path, {
                exportName: "exports",
                constantReexports,
                enumerableModuleMeta,
                strict,
                strictMode,
                allowTopLevelThis,
                noInterop,
                importInterop,
                lazy,
                esNamespaceOnly: typeof state.filename === "string" && /\.mjs$/.test(state.filename) ? mjsStrictNamespace : strictNamespace,
                noIncompleteNsImportDetection,
                filename: this.file.opts.filename
              });
              for (const [source2, metadata] of meta.source) {
                const loadExpr = _core.types.callExpression(_core.types.identifier("require"), [_core.types.stringLiteral(source2)]);
                let header;
                if ((0, _helperModuleTransforms.isSideEffectImport)(metadata)) {
                  if (metadata.lazy)
                    throw new Error("Assertion failure");
                  header = _core.types.expressionStatement(loadExpr);
                } else {
                  if (metadata.lazy && !metadata.referenced) {
                    continue;
                  }
                  const init = (0, _helperModuleTransforms.wrapInterop)(path, loadExpr, metadata.interop) || loadExpr;
                  if (metadata.lazy) {
                    header = _core.template.statement.ast`
                  function ${metadata.name}() {
                    const data = ${init};
                    ${metadata.name} = function(){ return data; };
                    return data;
                  }
                `;
                  } else {
                    header = _core.template.statement.ast`
                  var ${metadata.name} = ${init};
                `;
                  }
                }
                header.loc = metadata.loc;
                headers.push(header);
                headers.push(...(0, _helperModuleTransforms.buildNamespaceInitStatements)(meta, metadata, constantReexports));
              }
              (0, _helperModuleTransforms.ensureStatementsHoisted)(headers);
              path.unshiftContainer("body", headers);
              path.get("body").forEach((path2) => {
                if (headers.indexOf(path2.node) === -1)
                  return;
                if (path2.isVariableDeclaration()) {
                  path2.scope.registerDeclaration(path2);
                }
              });
            }
          }
        }
      };
    });
    exports.default = _default;
  }
});

// node_modules/@babel/preset-typescript/lib/index.js
var require_lib31 = __commonJS({
  "node_modules/@babel/preset-typescript/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var helperPluginUtils = require_lib20();
    var transformTypeScript = require_lib28();
    require_lib29();
    var transformModulesCommonJS = require_lib30();
    var helperValidatorOption = require_lib18();
    function _interopDefaultLegacy(e) {
      return e && typeof e === "object" && "default" in e ? e : { "default": e };
    }
    var transformTypeScript__default = /* @__PURE__ */ _interopDefaultLegacy(transformTypeScript);
    var transformModulesCommonJS__default = /* @__PURE__ */ _interopDefaultLegacy(transformModulesCommonJS);
    var v = new helperValidatorOption.OptionValidator("@babel/preset-typescript");
    function normalizeOptions(options = {}) {
      let {
        allowNamespaces = true,
        jsxPragma,
        onlyRemoveTypeImports
      } = options;
      const TopLevelOptions = {
        ignoreExtensions: "ignoreExtensions",
        allowNamespaces: "allowNamespaces",
        disallowAmbiguousJSXLike: "disallowAmbiguousJSXLike",
        jsxPragma: "jsxPragma",
        jsxPragmaFrag: "jsxPragmaFrag",
        onlyRemoveTypeImports: "onlyRemoveTypeImports",
        optimizeConstEnums: "optimizeConstEnums",
        allExtensions: "allExtensions",
        isTSX: "isTSX"
      };
      const jsxPragmaFrag = v.validateStringOption(TopLevelOptions.jsxPragmaFrag, options.jsxPragmaFrag, "React.Fragment");
      {
        var allExtensions = v.validateBooleanOption(TopLevelOptions.allExtensions, options.allExtensions, false);
        var isTSX = v.validateBooleanOption(TopLevelOptions.isTSX, options.isTSX, false);
        if (isTSX) {
          v.invariant(allExtensions, "isTSX:true requires allExtensions:true");
        }
      }
      const ignoreExtensions = v.validateBooleanOption(TopLevelOptions.ignoreExtensions, options.ignoreExtensions, false);
      const disallowAmbiguousJSXLike = v.validateBooleanOption(TopLevelOptions.disallowAmbiguousJSXLike, options.disallowAmbiguousJSXLike, false);
      if (disallowAmbiguousJSXLike) {
        {
          v.invariant(allExtensions, "disallowAmbiguousJSXLike:true requires allExtensions:true");
        }
      }
      const optimizeConstEnums = v.validateBooleanOption(TopLevelOptions.optimizeConstEnums, options.optimizeConstEnums, false);
      const normalized = {
        ignoreExtensions,
        allowNamespaces,
        disallowAmbiguousJSXLike,
        jsxPragma,
        jsxPragmaFrag,
        onlyRemoveTypeImports,
        optimizeConstEnums
      };
      {
        normalized.allExtensions = allExtensions;
        normalized.isTSX = isTSX;
      }
      return normalized;
    }
    var index2 = helperPluginUtils.declarePreset((api, opts) => {
      api.assertVersion(7);
      const {
        allExtensions,
        allowNamespaces,
        disallowAmbiguousJSXLike,
        isTSX,
        jsxPragma,
        jsxPragmaFrag,
        onlyRemoveTypeImports,
        optimizeConstEnums
      } = normalizeOptions(opts);
      const pluginOptions = (disallowAmbiguousJSXLike2) => ({
        allowDeclareFields: opts.allowDeclareFields,
        allowNamespaces,
        disallowAmbiguousJSXLike: disallowAmbiguousJSXLike2,
        jsxPragma,
        jsxPragmaFrag,
        onlyRemoveTypeImports,
        optimizeConstEnums
      });
      const getPlugins = (isTSX2, disallowAmbiguousJSXLike2) => {
        {
          return [[transformTypeScript__default["default"], Object.assign({
            isTSX: isTSX2
          }, pluginOptions(disallowAmbiguousJSXLike2))]];
        }
      };
      return {
        overrides: allExtensions ? [{
          plugins: getPlugins(isTSX, disallowAmbiguousJSXLike)
        }] : [{
          test: /\.ts$/,
          plugins: getPlugins(false, false)
        }, {
          test: /\.mts$/,
          sourceType: "module",
          plugins: getPlugins(false, true)
        }, {
          test: /\.cts$/,
          sourceType: "unambiguous",
          plugins: [[transformModulesCommonJS__default["default"], {
            allowTopLevelThis: true
          }], [transformTypeScript__default["default"], pluginOptions(true)]]
        }, {
          test: /\.tsx$/,
          plugins: getPlugins(true, false)
        }]
      };
    });
    exports["default"] = index2;
  }
});

// node_modules/@babel/core/lib/config/files/module-types.js
var require_module_types = __commonJS({
  "node_modules/@babel/core/lib/config/files/module-types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = loadCodeDefault;
    exports.supportsESM = void 0;
    var _async = require_async();
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _url() {
      const data3 = require("url");
      _url = function() {
        return data3;
      };
      return data3;
    }
    function _semver() {
      const data3 = require_semver();
      _semver = function() {
        return data3;
      };
      return data3;
    }
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var _configError = require_config_error();
    var _transformFile = require_transform_file();
    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key2, arg) {
      try {
        var info = gen[key2](arg);
        var value2 = info.value;
      } catch (error) {
        reject(error);
        return;
      }
      if (info.done) {
        resolve(value2);
      } else {
        Promise.resolve(value2).then(_next, _throw);
      }
    }
    function _asyncToGenerator(fn) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve, reject) {
          var gen = fn.apply(self2, args);
          function _next(value2) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value2);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
          }
          _next(void 0);
        });
      };
    }
    var import_;
    try {
      import_ = require_import();
    } catch (_unused) {
    }
    var supportsESM = _semver().satisfies(process.versions.node, "^12.17 || >=13.2");
    exports.supportsESM = supportsESM;
    function* loadCodeDefault(filepath, asyncError, fallbackToTranspiledModule = false) {
      switch (_path().extname(filepath)) {
        case ".cjs":
          return loadCjsDefault(filepath, fallbackToTranspiledModule);
        case ".mjs":
          break;
        case ".cts":
          return loadCtsDefault(filepath);
        default:
          try {
            return loadCjsDefault(filepath, fallbackToTranspiledModule);
          } catch (e) {
            if (e.code !== "ERR_REQUIRE_ESM")
              throw e;
          }
      }
      if (yield* (0, _async.isAsync)()) {
        return yield* (0, _async.waitFor)(loadMjsDefault(filepath));
      }
      throw new _configError.default(asyncError, filepath);
    }
    function loadCtsDefault(filepath) {
      const ext = ".cts";
      const hasTsSupport = !!(require.extensions[".ts"] || require.extensions[".cts"] || require.extensions[".mts"]);
      let handler;
      if (!hasTsSupport) {
        const opts = {
          babelrc: false,
          configFile: false,
          sourceType: "unambiguous",
          sourceMaps: "inline",
          sourceFileName: _path().basename(filepath),
          presets: [[getTSPreset(filepath), Object.assign({
            onlyRemoveTypeImports: true,
            optimizeConstEnums: true
          }, {
            allowDeclareFields: true
          })]]
        };
        handler = function(m, filename) {
          if (handler && filename.endsWith(ext)) {
            try {
              return m._compile((0, _transformFile.transformFileSync)(filename, Object.assign({}, opts, {
                filename
              })).code, filename);
            } catch (error) {
              if (!hasTsSupport) {
                const packageJson = require_package2();
                if (_semver().lte(packageJson.version, "7.21.4")) {
                  console.error("`.cts` configuration file failed to load, please try to update `@babel/preset-typescript`.");
                }
              }
              throw error;
            }
          }
          return require.extensions[".js"](m, filename);
        };
        require.extensions[ext] = handler;
      }
      try {
        const module3 = (0, _rewriteStackTrace.endHiddenCallStack)(require)(filepath);
        return module3 != null && module3.__esModule ? module3.default : module3;
      } finally {
        if (!hasTsSupport) {
          if (require.extensions[ext] === handler)
            delete require.extensions[ext];
          handler = void 0;
        }
      }
    }
    function loadCjsDefault(filepath, fallbackToTranspiledModule) {
      const module3 = (0, _rewriteStackTrace.endHiddenCallStack)(require)(filepath);
      return module3 != null && module3.__esModule ? module3.default || (fallbackToTranspiledModule ? module3 : void 0) : module3;
    }
    function loadMjsDefault(_x) {
      return _loadMjsDefault.apply(this, arguments);
    }
    function _loadMjsDefault() {
      _loadMjsDefault = _asyncToGenerator(function* (filepath) {
        if (!import_) {
          throw new _configError.default("Internal error: Native ECMAScript modules aren't supported by this platform.\n", filepath);
        }
        const module3 = yield (0, _rewriteStackTrace.endHiddenCallStack)(import_)((0, _url().pathToFileURL)(filepath));
        return module3.default;
      });
      return _loadMjsDefault.apply(this, arguments);
    }
    function getTSPreset(filepath) {
      try {
        return require_lib31();
      } catch (error) {
        if (error.code !== "MODULE_NOT_FOUND")
          throw error;
        let message = "You appear to be using a .cts file as Babel configuration, but the `@babel/preset-typescript` package was not found: please install it!";
        if (process.versions.pnp) {
          message += `
If you are using Yarn Plug'n'Play, you may also need to add the following configuration to your .yarnrc.yml file:

packageExtensions:
	"@babel/core@*":
		peerDependencies:
			"@babel/preset-typescript": "*"
`;
        }
        throw new _configError.default(message, filepath);
      }
    }
  }
});

// node_modules/@babel/core/lib/config/files/configuration.js
var require_configuration = __commonJS({
  "node_modules/@babel/core/lib/config/files/configuration.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ROOT_CONFIG_FILENAMES = void 0;
    exports.findConfigUpwards = findConfigUpwards;
    exports.findRelativeConfig = findRelativeConfig;
    exports.findRootConfig = findRootConfig;
    exports.loadConfig = loadConfig;
    exports.resolveShowConfigPath = resolveShowConfigPath;
    function _debug() {
      const data3 = require_src();
      _debug = function() {
        return data3;
      };
      return data3;
    }
    function _fs() {
      const data3 = require("fs");
      _fs = function() {
        return data3;
      };
      return data3;
    }
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _json() {
      const data3 = (init_dist(), __toCommonJS(dist_exports));
      _json = function() {
        return data3;
      };
      return data3;
    }
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _caching = require_caching();
    var _configApi = require_config_api();
    var _utils = require_utils2();
    var _moduleTypes = require_module_types();
    var _patternToRegex = require_pattern_to_regex();
    var _configError = require_config_error();
    var fs = require_fs();
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var debug = _debug()("babel:config:loading:files:configuration");
    var ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts"];
    exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
    var RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json", ".babelrc.cts"];
    var BABELIGNORE_FILENAME = ".babelignore";
    var LOADING_CONFIGS = /* @__PURE__ */ new Set();
    var readConfigCode = (0, _caching.makeStrongCache)(function* readConfigCode2(filepath, cache) {
      if (!_fs().existsSync(filepath)) {
        cache.never();
        return null;
      }
      if (LOADING_CONFIGS.has(filepath)) {
        cache.never();
        debug("Auto-ignoring usage of config %o.", filepath);
        return {
          filepath,
          dirname: _path().dirname(filepath),
          options: {}
        };
      }
      let options;
      try {
        LOADING_CONFIGS.add(filepath);
        options = yield* (0, _moduleTypes.default)(filepath, "You appear to be using a native ECMAScript module configuration file, which is only supported when running Babel asynchronously.");
      } finally {
        LOADING_CONFIGS.delete(filepath);
      }
      let assertCache = false;
      if (typeof options === "function") {
        yield* [];
        options = (0, _rewriteStackTrace.endHiddenCallStack)(options)((0, _configApi.makeConfigAPI)(cache));
        assertCache = true;
      }
      if (!options || typeof options !== "object" || Array.isArray(options)) {
        throw new _configError.default(`Configuration should be an exported JavaScript object.`, filepath);
      }
      if (typeof options.then === "function") {
        throw new _configError.default(`You appear to be using an async configuration, which your current version of Babel does not support. We may add support for this in the future, but if you're on the most recent version of @babel/core and still seeing this error, then you'll need to synchronously return your config.`, filepath);
      }
      if (assertCache && !cache.configured())
        throwConfigError(filepath);
      return {
        filepath,
        dirname: _path().dirname(filepath),
        options
      };
    });
    var packageToBabelConfig = (0, _caching.makeWeakCacheSync)((file) => {
      const babel = file.options["babel"];
      if (typeof babel === "undefined")
        return null;
      if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
        throw new _configError.default(`.babel property must be an object`, file.filepath);
      }
      return {
        filepath: file.filepath,
        dirname: file.dirname,
        options: babel
      };
    });
    var readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content3) => {
      let options;
      try {
        options = _json().parse(content3);
      } catch (err) {
        throw new _configError.default(`Error while parsing config - ${err.message}`, filepath);
      }
      if (!options)
        throw new _configError.default(`No config detected`, filepath);
      if (typeof options !== "object") {
        throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
      }
      if (Array.isArray(options)) {
        throw new _configError.default(`Expected config object but found array`, filepath);
      }
      delete options["$schema"];
      return {
        filepath,
        dirname: _path().dirname(filepath),
        options
      };
    });
    var readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content3) => {
      const ignoreDir = _path().dirname(filepath);
      const ignorePatterns = content3.split("\n").map((line2) => line2.replace(/#(.*?)$/, "").trim()).filter((line2) => !!line2);
      for (const pattern of ignorePatterns) {
        if (pattern[0] === "!") {
          throw new _configError.default(`Negation of file paths is not supported.`, filepath);
        }
      }
      return {
        filepath,
        dirname: _path().dirname(filepath),
        ignore: ignorePatterns.map((pattern) => (0, _patternToRegex.default)(pattern, ignoreDir))
      };
    });
    function findConfigUpwards(rootDir) {
      let dirname = rootDir;
      for (; ; ) {
        for (const filename of ROOT_CONFIG_FILENAMES) {
          if (_fs().existsSync(_path().join(dirname, filename))) {
            return dirname;
          }
        }
        const nextDir = _path().dirname(dirname);
        if (dirname === nextDir)
          break;
        dirname = nextDir;
      }
      return null;
    }
    function* findRelativeConfig(packageData, envName, caller) {
      let config = null;
      let ignore3 = null;
      const dirname = _path().dirname(packageData.filepath);
      for (const loc of packageData.directories) {
        if (!config) {
          var _packageData$pkg;
          config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null);
        }
        if (!ignore3) {
          const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME);
          ignore3 = yield* readIgnoreConfig(ignoreLoc);
          if (ignore3) {
            debug("Found ignore %o from %o.", ignore3.filepath, dirname);
          }
        }
      }
      return {
        config,
        ignore: ignore3
      };
    }
    function findRootConfig(dirname, envName, caller) {
      return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
    }
    function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
      const configs = yield* _gensync().all(names.map((filename) => readConfig(_path().join(dirname, filename), envName, caller)));
      const config = configs.reduce((previousConfig2, config2) => {
        if (config2 && previousConfig2) {
          throw new _configError.default(`Multiple configuration files found. Please remove one:
 - ${_path().basename(previousConfig2.filepath)}
 - ${config2.filepath}
from ${dirname}`);
        }
        return config2 || previousConfig2;
      }, previousConfig);
      if (config) {
        debug("Found configuration %o from %o.", config.filepath, dirname);
      }
      return config;
    }
    function* loadConfig(name2, dirname, envName, caller) {
      const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
        paths: [b]
      }, M = require("module")) => {
        let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
        if (f)
          return f;
        f = new Error(`Cannot resolve module '${r}'`);
        f.code = "MODULE_NOT_FOUND";
        throw f;
      })(name2, {
        paths: [dirname]
      });
      const conf = yield* readConfig(filepath, envName, caller);
      if (!conf) {
        throw new _configError.default(`Config file contains no configuration data`, filepath);
      }
      debug("Loaded config %o from %o.", name2, dirname);
      return conf;
    }
    function readConfig(filepath, envName, caller) {
      const ext = _path().extname(filepath);
      switch (ext) {
        case ".js":
        case ".cjs":
        case ".mjs":
        case ".cts":
          return readConfigCode(filepath, {
            envName,
            caller
          });
        default:
          return readConfigJSON5(filepath);
      }
    }
    function* resolveShowConfigPath(dirname) {
      const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
      if (targetPath != null) {
        const absolutePath = _path().resolve(dirname, targetPath);
        const stats = yield* fs.stat(absolutePath);
        if (!stats.isFile()) {
          throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`);
        }
        return absolutePath;
      }
      return null;
    }
    function throwConfigError(filepath) {
      throw new _configError.default(`Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
for various types of caching, using the first param of their handler functions:

module.exports = function(api) {
  // The API exposes the following:

  // Cache the returned value forever and don't call this function again.
  api.cache(true);

  // Don't cache at all. Not recommended because it will be very slow.
  api.cache(false);

  // Cached based on the value of some function. If this function returns a value different from
  // a previously-encountered value, the plugins will re-evaluate.
  var env = api.cache(() => process.env.NODE_ENV);

  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
  // any possible NODE_ENV value that might come up during plugin execution.
  var isProd = api.cache(() => process.env.NODE_ENV === "production");

  // .cache(fn) will perform a linear search though instances to find the matching plugin based
  // based on previous instantiated plugins. If you want to recreate the plugin and discard the
  // previous instance whenever something changes, you may use:
  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");

  // Note, we also expose the following more-verbose versions of the above examples:
  api.cache.forever(); // api.cache(true)
  api.cache.never();   // api.cache(false)
  api.cache.using(fn); // api.cache(fn)

  // Return the value that will be cached.
  return { };
};`, filepath);
    }
  }
});

// node_modules/@babel/core/lib/vendor/import-meta-resolve.js
var require_import_meta_resolve = __commonJS({
  "node_modules/@babel/core/lib/vendor/import-meta-resolve.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.moduleResolve = moduleResolve;
    exports.resolve = resolve;
    function _url() {
      const data3 = require("url");
      _url = function() {
        return data3;
      };
      return data3;
    }
    function _fs() {
      const data3 = _interopRequireWildcard(require("fs"), true);
      _fs = function() {
        return data3;
      };
      return data3;
    }
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _assert() {
      const data3 = require("assert");
      _assert = function() {
        return data3;
      };
      return data3;
    }
    function _util() {
      const data3 = require("util");
      _util = function() {
        return data3;
      };
      return data3;
    }
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function")
        return null;
      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
      return (_getRequireWildcardCache = function(nodeInterop2) {
        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (!nodeInterop && obj && obj.__esModule) {
        return obj;
      }
      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return { default: obj };
      }
      var cache = _getRequireWildcardCache(nodeInterop);
      if (cache && cache.has(obj)) {
        return cache.get(obj);
      }
      var newObj = {};
      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
      for (var key2 in obj) {
        if (key2 !== "default" && Object.prototype.hasOwnProperty.call(obj, key2)) {
          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key2) : null;
          if (desc && (desc.get || desc.set)) {
            Object.defineProperty(newObj, key2, desc);
          } else {
            newObj[key2] = obj[key2];
          }
        }
      }
      newObj.default = obj;
      if (cache) {
        cache.set(obj, newObj);
      }
      return newObj;
    }
    function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key2, arg) {
      try {
        var info = gen[key2](arg);
        var value2 = info.value;
      } catch (error) {
        reject(error);
        return;
      }
      if (info.done) {
        resolve2(value2);
      } else {
        Promise.resolve(value2).then(_next, _throw);
      }
    }
    function _asyncToGenerator(fn) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve2, reject) {
          var gen = fn.apply(self2, args);
          function _next(value2) {
            asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value2);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
          }
          _next(void 0);
        });
      };
    }
    var re$3 = {
      exports: {}
    };
    var SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH$2 = 256;
    var MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || 9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var constants = {
      SEMVER_SPEC_VERSION,
      MAX_LENGTH: MAX_LENGTH$2,
      MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
      MAX_SAFE_COMPONENT_LENGTH
    };
    var debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
    };
    var debug_1 = debug$1;
    (function(module3, exports2) {
      const {
        MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2
      } = constants;
      const debug2 = debug_1;
      exports2 = module3.exports = {};
      const re2 = exports2.re = [];
      const src = exports2.src = [];
      const t4 = exports2.t = {};
      let R = 0;
      const createToken = (name2, value2, isGlobal) => {
        const index2 = R++;
        debug2(name2, index2, value2);
        t4[name2] = index2;
        src[index2] = value2;
        re2[index2] = new RegExp(value2, isGlobal ? "g" : void 0);
      };
      createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
      createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+");
      createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*");
      createToken("MAINVERSION", `(${src[t4.NUMERICIDENTIFIER]})\\.(${src[t4.NUMERICIDENTIFIER]})\\.(${src[t4.NUMERICIDENTIFIER]})`);
      createToken("MAINVERSIONLOOSE", `(${src[t4.NUMERICIDENTIFIERLOOSE]})\\.(${src[t4.NUMERICIDENTIFIERLOOSE]})\\.(${src[t4.NUMERICIDENTIFIERLOOSE]})`);
      createToken("PRERELEASEIDENTIFIER", `(?:${src[t4.NUMERICIDENTIFIER]}|${src[t4.NONNUMERICIDENTIFIER]})`);
      createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t4.NUMERICIDENTIFIERLOOSE]}|${src[t4.NONNUMERICIDENTIFIER]})`);
      createToken("PRERELEASE", `(?:-(${src[t4.PRERELEASEIDENTIFIER]}(?:\\.${src[t4.PRERELEASEIDENTIFIER]})*))`);
      createToken("PRERELEASELOOSE", `(?:-?(${src[t4.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t4.PRERELEASEIDENTIFIERLOOSE]})*))`);
      createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+");
      createToken("BUILD", `(?:\\+(${src[t4.BUILDIDENTIFIER]}(?:\\.${src[t4.BUILDIDENTIFIER]})*))`);
      createToken("FULLPLAIN", `v?${src[t4.MAINVERSION]}${src[t4.PRERELEASE]}?${src[t4.BUILD]}?`);
      createToken("FULL", `^${src[t4.FULLPLAIN]}$`);
      createToken("LOOSEPLAIN", `[v=\\s]*${src[t4.MAINVERSIONLOOSE]}${src[t4.PRERELEASELOOSE]}?${src[t4.BUILD]}?`);
      createToken("LOOSE", `^${src[t4.LOOSEPLAIN]}$`);
      createToken("GTLT", "((?:<|>)?=?)");
      createToken("XRANGEIDENTIFIERLOOSE", `${src[t4.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
      createToken("XRANGEIDENTIFIER", `${src[t4.NUMERICIDENTIFIER]}|x|X|\\*`);
      createToken("XRANGEPLAIN", `[v=\\s]*(${src[t4.XRANGEIDENTIFIER]})(?:\\.(${src[t4.XRANGEIDENTIFIER]})(?:\\.(${src[t4.XRANGEIDENTIFIER]})(?:${src[t4.PRERELEASE]})?${src[t4.BUILD]}?)?)?`);
      createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t4.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t4.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t4.XRANGEIDENTIFIERLOOSE]})(?:${src[t4.PRERELEASELOOSE]})?${src[t4.BUILD]}?)?)?`);
      createToken("XRANGE", `^${src[t4.GTLT]}\\s*${src[t4.XRANGEPLAIN]}$`);
      createToken("XRANGELOOSE", `^${src[t4.GTLT]}\\s*${src[t4.XRANGEPLAINLOOSE]}$`);
      createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:$|[^\\d])`);
      createToken("COERCERTL", src[t4.COERCE], true);
      createToken("LONETILDE", "(?:~>?)");
      createToken("TILDETRIM", `(\\s*)${src[t4.LONETILDE]}\\s+`, true);
      exports2.tildeTrimReplace = "$1~";
      createToken("TILDE", `^${src[t4.LONETILDE]}${src[t4.XRANGEPLAIN]}$`);
      createToken("TILDELOOSE", `^${src[t4.LONETILDE]}${src[t4.XRANGEPLAINLOOSE]}$`);
      createToken("LONECARET", "(?:\\^)");
      createToken("CARETTRIM", `(\\s*)${src[t4.LONECARET]}\\s+`, true);
      exports2.caretTrimReplace = "$1^";
      createToken("CARET", `^${src[t4.LONECARET]}${src[t4.XRANGEPLAIN]}$`);
      createToken("CARETLOOSE", `^${src[t4.LONECARET]}${src[t4.XRANGEPLAINLOOSE]}$`);
      createToken("COMPARATORLOOSE", `^${src[t4.GTLT]}\\s*(${src[t4.LOOSEPLAIN]})$|^$`);
      createToken("COMPARATOR", `^${src[t4.GTLT]}\\s*(${src[t4.FULLPLAIN]})$|^$`);
      createToken("COMPARATORTRIM", `(\\s*)${src[t4.GTLT]}\\s*(${src[t4.LOOSEPLAIN]}|${src[t4.XRANGEPLAIN]})`, true);
      exports2.comparatorTrimReplace = "$1$2$3";
      createToken("HYPHENRANGE", `^\\s*(${src[t4.XRANGEPLAIN]})\\s+-\\s+(${src[t4.XRANGEPLAIN]})\\s*$`);
      createToken("HYPHENRANGELOOSE", `^\\s*(${src[t4.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t4.XRANGEPLAINLOOSE]})\\s*$`);
      createToken("STAR", "(<|>)?=?\\s*\\*");
      createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
      createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
    })(re$3, re$3.exports);
    var opts = ["includePrerelease", "loose", "rtl"];
    var parseOptions$2 = (options) => !options ? {} : typeof options !== "object" ? {
      loose: true
    } : opts.filter((k) => options[k]).reduce((o, k) => {
      o[k] = true;
      return o;
    }, {});
    var parseOptions_1 = parseOptions$2;
    var numeric = /^[0-9]+$/;
    var compareIdentifiers$1 = (a, b) => {
      const anum = numeric.test(a);
      const bnum = numeric.test(b);
      if (anum && bnum) {
        a = +a;
        b = +b;
      }
      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
    };
    var rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
    var identifiers = {
      compareIdentifiers: compareIdentifiers$1,
      rcompareIdentifiers
    };
    var debug = debug_1;
    var {
      MAX_LENGTH: MAX_LENGTH$1,
      MAX_SAFE_INTEGER
    } = constants;
    var {
      re: re$2,
      t: t$2
    } = re$3.exports;
    var parseOptions$1 = parseOptions_1;
    var {
      compareIdentifiers
    } = identifiers;
    var SemVer$c = class {
      constructor(version3, options) {
        options = parseOptions$1(options);
        if (version3 instanceof SemVer$c) {
          if (version3.loose === !!options.loose && version3.includePrerelease === !!options.includePrerelease) {
            return version3;
          } else {
            version3 = version3.version;
          }
        } else if (typeof version3 !== "string") {
          throw new TypeError(`Invalid Version: ${version3}`);
        }
        if (version3.length > MAX_LENGTH$1) {
          throw new TypeError(`version is longer than ${MAX_LENGTH$1} characters`);
        }
        debug("SemVer", version3, options);
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        const m = version3.trim().match(options.loose ? re$2[t$2.LOOSE] : re$2[t$2.FULL]);
        if (!m) {
          throw new TypeError(`Invalid Version: ${version3}`);
        }
        this.raw = version3;
        this.major = +m[1];
        this.minor = +m[2];
        this.patch = +m[3];
        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
          throw new TypeError("Invalid major version");
        }
        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
          throw new TypeError("Invalid minor version");
        }
        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
          throw new TypeError("Invalid patch version");
        }
        if (!m[4]) {
          this.prerelease = [];
        } else {
          this.prerelease = m[4].split(".").map((id) => {
            if (/^[0-9]+$/.test(id)) {
              const num = +id;
              if (num >= 0 && num < MAX_SAFE_INTEGER) {
                return num;
              }
            }
            return id;
          });
        }
        this.build = m[5] ? m[5].split(".") : [];
        this.format();
      }
      format() {
        this.version = `${this.major}.${this.minor}.${this.patch}`;
        if (this.prerelease.length) {
          this.version += `-${this.prerelease.join(".")}`;
        }
        return this.version;
      }
      toString() {
        return this.version;
      }
      compare(other) {
        debug("SemVer.compare", this.version, this.options, other);
        if (!(other instanceof SemVer$c)) {
          if (typeof other === "string" && other === this.version) {
            return 0;
          }
          other = new SemVer$c(other, this.options);
        }
        if (other.version === this.version) {
          return 0;
        }
        return this.compareMain(other) || this.comparePre(other);
      }
      compareMain(other) {
        if (!(other instanceof SemVer$c)) {
          other = new SemVer$c(other, this.options);
        }
        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
      }
      comparePre(other) {
        if (!(other instanceof SemVer$c)) {
          other = new SemVer$c(other, this.options);
        }
        if (this.prerelease.length && !other.prerelease.length) {
          return -1;
        } else if (!this.prerelease.length && other.prerelease.length) {
          return 1;
        } else if (!this.prerelease.length && !other.prerelease.length) {
          return 0;
        }
        let i = 0;
        do {
          const a = this.prerelease[i];
          const b = other.prerelease[i];
          debug("prerelease compare", i, a, b);
          if (a === void 0 && b === void 0) {
            return 0;
          } else if (b === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      }
      compareBuild(other) {
        if (!(other instanceof SemVer$c)) {
          other = new SemVer$c(other, this.options);
        }
        let i = 0;
        do {
          const a = this.build[i];
          const b = other.build[i];
          debug("prerelease compare", i, a, b);
          if (a === void 0 && b === void 0) {
            return 0;
          } else if (b === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      }
      inc(release, identifier) {
        switch (release) {
          case "premajor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor = 0;
            this.major++;
            this.inc("pre", identifier);
            break;
          case "preminor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor++;
            this.inc("pre", identifier);
            break;
          case "prepatch":
            this.prerelease.length = 0;
            this.inc("patch", identifier);
            this.inc("pre", identifier);
            break;
          case "prerelease":
            if (this.prerelease.length === 0) {
              this.inc("patch", identifier);
            }
            this.inc("pre", identifier);
            break;
          case "major":
            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
              this.major++;
            }
            this.minor = 0;
            this.patch = 0;
            this.prerelease = [];
            break;
          case "minor":
            if (this.patch !== 0 || this.prerelease.length === 0) {
              this.minor++;
            }
            this.patch = 0;
            this.prerelease = [];
            break;
          case "patch":
            if (this.prerelease.length === 0) {
              this.patch++;
            }
            this.prerelease = [];
            break;
          case "pre":
            if (this.prerelease.length === 0) {
              this.prerelease = [0];
            } else {
              let i = this.prerelease.length;
              while (--i >= 0) {
                if (typeof this.prerelease[i] === "number") {
                  this.prerelease[i]++;
                  i = -2;
                }
              }
              if (i === -1) {
                this.prerelease.push(0);
              }
            }
            if (identifier) {
              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
                if (isNaN(this.prerelease[1])) {
                  this.prerelease = [identifier, 0];
                }
              } else {
                this.prerelease = [identifier, 0];
              }
            }
            break;
          default:
            throw new Error(`invalid increment argument: ${release}`);
        }
        this.format();
        this.raw = this.version;
        return this;
      }
    };
    var semver$2 = SemVer$c;
    var {
      MAX_LENGTH
    } = constants;
    var {
      re: re$1,
      t: t$1
    } = re$3.exports;
    var SemVer$b = semver$2;
    var parseOptions = parseOptions_1;
    var parse$5 = (version3, options) => {
      options = parseOptions(options);
      if (version3 instanceof SemVer$b) {
        return version3;
      }
      if (typeof version3 !== "string") {
        return null;
      }
      if (version3.length > MAX_LENGTH) {
        return null;
      }
      const r = options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL];
      if (!r.test(version3)) {
        return null;
      }
      try {
        return new SemVer$b(version3, options);
      } catch (er) {
        return null;
      }
    };
    var parse_1 = parse$5;
    var parse$4 = parse_1;
    var valid$1 = (version3, options) => {
      const v = parse$4(version3, options);
      return v ? v.version : null;
    };
    var valid_1 = valid$1;
    var parse$3 = parse_1;
    var clean2 = (version3, options) => {
      const s = parse$3(version3.trim().replace(/^[=v]+/, ""), options);
      return s ? s.version : null;
    };
    var clean_1 = clean2;
    var SemVer$a = semver$2;
    var inc = (version3, release, options, identifier) => {
      if (typeof options === "string") {
        identifier = options;
        options = void 0;
      }
      try {
        return new SemVer$a(version3 instanceof SemVer$a ? version3.version : version3, options).inc(release, identifier).version;
      } catch (er) {
        return null;
      }
    };
    var inc_1 = inc;
    var SemVer$9 = semver$2;
    var compare$a = (a, b, loose) => new SemVer$9(a, loose).compare(new SemVer$9(b, loose));
    var compare_1 = compare$a;
    var compare$9 = compare_1;
    var eq$2 = (a, b, loose) => compare$9(a, b, loose) === 0;
    var eq_1 = eq$2;
    var parse$2 = parse_1;
    var eq$1 = eq_1;
    var diff = (version1, version22) => {
      if (eq$1(version1, version22)) {
        return null;
      } else {
        const v1 = parse$2(version1);
        const v2 = parse$2(version22);
        const hasPre = v1.prerelease.length || v2.prerelease.length;
        const prefix = hasPre ? "pre" : "";
        const defaultResult = hasPre ? "prerelease" : "";
        for (const key2 in v1) {
          if (key2 === "major" || key2 === "minor" || key2 === "patch") {
            if (v1[key2] !== v2[key2]) {
              return prefix + key2;
            }
          }
        }
        return defaultResult;
      }
    };
    var diff_1 = diff;
    var SemVer$8 = semver$2;
    var major = (a, loose) => new SemVer$8(a, loose).major;
    var major_1 = major;
    var SemVer$7 = semver$2;
    var minor = (a, loose) => new SemVer$7(a, loose).minor;
    var minor_1 = minor;
    var SemVer$6 = semver$2;
    var patch3 = (a, loose) => new SemVer$6(a, loose).patch;
    var patch_1 = patch3;
    var parse$1 = parse_1;
    var prerelease = (version3, options) => {
      const parsed = parse$1(version3, options);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    };
    var prerelease_1 = prerelease;
    var compare$8 = compare_1;
    var rcompare = (a, b, loose) => compare$8(b, a, loose);
    var rcompare_1 = rcompare;
    var compare$7 = compare_1;
    var compareLoose = (a, b) => compare$7(a, b, true);
    var compareLoose_1 = compareLoose;
    var SemVer$5 = semver$2;
    var compareBuild$2 = (a, b, loose) => {
      const versionA = new SemVer$5(a, loose);
      const versionB = new SemVer$5(b, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    };
    var compareBuild_1 = compareBuild$2;
    var compareBuild$1 = compareBuild_1;
    var sort = (list3, loose) => list3.sort((a, b) => compareBuild$1(a, b, loose));
    var sort_1 = sort;
    var compareBuild = compareBuild_1;
    var rsort = (list3, loose) => list3.sort((a, b) => compareBuild(b, a, loose));
    var rsort_1 = rsort;
    var compare$6 = compare_1;
    var gt$3 = (a, b, loose) => compare$6(a, b, loose) > 0;
    var gt_1 = gt$3;
    var compare$5 = compare_1;
    var lt$2 = (a, b, loose) => compare$5(a, b, loose) < 0;
    var lt_1 = lt$2;
    var compare$4 = compare_1;
    var neq$1 = (a, b, loose) => compare$4(a, b, loose) !== 0;
    var neq_1 = neq$1;
    var compare$3 = compare_1;
    var gte$2 = (a, b, loose) => compare$3(a, b, loose) >= 0;
    var gte_1 = gte$2;
    var compare$2 = compare_1;
    var lte$2 = (a, b, loose) => compare$2(a, b, loose) <= 0;
    var lte_1 = lte$2;
    var eq = eq_1;
    var neq = neq_1;
    var gt$2 = gt_1;
    var gte$1 = gte_1;
    var lt$1 = lt_1;
    var lte$1 = lte_1;
    var cmp = (a, op, b, loose) => {
      switch (op) {
        case "===":
          if (typeof a === "object") {
            a = a.version;
          }
          if (typeof b === "object") {
            b = b.version;
          }
          return a === b;
        case "!==":
          if (typeof a === "object") {
            a = a.version;
          }
          if (typeof b === "object") {
            b = b.version;
          }
          return a !== b;
        case "":
        case "=":
        case "==":
          return eq(a, b, loose);
        case "!=":
          return neq(a, b, loose);
        case ">":
          return gt$2(a, b, loose);
        case ">=":
          return gte$1(a, b, loose);
        case "<":
          return lt$1(a, b, loose);
        case "<=":
          return lte$1(a, b, loose);
        default:
          throw new TypeError(`Invalid operator: ${op}`);
      }
    };
    var cmp_1 = cmp;
    var SemVer$4 = semver$2;
    var parse9 = parse_1;
    var {
      re,
      t: t3
    } = re$3.exports;
    var coerce = (version3, options) => {
      if (version3 instanceof SemVer$4) {
        return version3;
      }
      if (typeof version3 === "number") {
        version3 = String(version3);
      }
      if (typeof version3 !== "string") {
        return null;
      }
      options = options || {};
      let match = null;
      if (!options.rtl) {
        match = version3.match(re[t3.COERCE]);
      } else {
        let next;
        while ((next = re[t3.COERCERTL].exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
          if (!match || next.index + next[0].length !== match.index + match[0].length) {
            match = next;
          }
          re[t3.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
        }
        re[t3.COERCERTL].lastIndex = -1;
      }
      if (match === null) {
        return null;
      }
      return parse9(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
    };
    var coerce_1 = coerce;
    var iterator;
    var hasRequiredIterator;
    function requireIterator() {
      if (hasRequiredIterator)
        return iterator;
      hasRequiredIterator = 1;
      iterator = function(Yallist) {
        Yallist.prototype[Symbol.iterator] = function* () {
          for (let walker = this.head; walker; walker = walker.next) {
            yield walker.value;
          }
        };
      };
      return iterator;
    }
    var yallist;
    var hasRequiredYallist;
    function requireYallist() {
      if (hasRequiredYallist)
        return yallist;
      hasRequiredYallist = 1;
      yallist = Yallist;
      Yallist.Node = Node5;
      Yallist.create = Yallist;
      function Yallist(list3) {
        var self2 = this;
        if (!(self2 instanceof Yallist)) {
          self2 = new Yallist();
        }
        self2.tail = null;
        self2.head = null;
        self2.length = 0;
        if (list3 && typeof list3.forEach === "function") {
          list3.forEach(function(item) {
            self2.push(item);
          });
        } else if (arguments.length > 0) {
          for (var i = 0, l = arguments.length; i < l; i++) {
            self2.push(arguments[i]);
          }
        }
        return self2;
      }
      Yallist.prototype.removeNode = function(node2) {
        if (node2.list !== this) {
          throw new Error("removing node which does not belong to this list");
        }
        var next = node2.next;
        var prev = node2.prev;
        if (next) {
          next.prev = prev;
        }
        if (prev) {
          prev.next = next;
        }
        if (node2 === this.head) {
          this.head = next;
        }
        if (node2 === this.tail) {
          this.tail = prev;
        }
        node2.list.length--;
        node2.next = null;
        node2.prev = null;
        node2.list = null;
        return next;
      };
      Yallist.prototype.unshiftNode = function(node2) {
        if (node2 === this.head) {
          return;
        }
        if (node2.list) {
          node2.list.removeNode(node2);
        }
        var head = this.head;
        node2.list = this;
        node2.next = head;
        if (head) {
          head.prev = node2;
        }
        this.head = node2;
        if (!this.tail) {
          this.tail = node2;
        }
        this.length++;
      };
      Yallist.prototype.pushNode = function(node2) {
        if (node2 === this.tail) {
          return;
        }
        if (node2.list) {
          node2.list.removeNode(node2);
        }
        var tail = this.tail;
        node2.list = this;
        node2.prev = tail;
        if (tail) {
          tail.next = node2;
        }
        this.tail = node2;
        if (!this.head) {
          this.head = node2;
        }
        this.length++;
      };
      Yallist.prototype.push = function() {
        for (var i = 0, l = arguments.length; i < l; i++) {
          push3(this, arguments[i]);
        }
        return this.length;
      };
      Yallist.prototype.unshift = function() {
        for (var i = 0, l = arguments.length; i < l; i++) {
          unshift(this, arguments[i]);
        }
        return this.length;
      };
      Yallist.prototype.pop = function() {
        if (!this.tail) {
          return void 0;
        }
        var res = this.tail.value;
        this.tail = this.tail.prev;
        if (this.tail) {
          this.tail.next = null;
        } else {
          this.head = null;
        }
        this.length--;
        return res;
      };
      Yallist.prototype.shift = function() {
        if (!this.head) {
          return void 0;
        }
        var res = this.head.value;
        this.head = this.head.next;
        if (this.head) {
          this.head.prev = null;
        } else {
          this.tail = null;
        }
        this.length--;
        return res;
      };
      Yallist.prototype.forEach = function(fn, thisp) {
        thisp = thisp || this;
        for (var walker = this.head, i = 0; walker !== null; i++) {
          fn.call(thisp, walker.value, i, this);
          walker = walker.next;
        }
      };
      Yallist.prototype.forEachReverse = function(fn, thisp) {
        thisp = thisp || this;
        for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
          fn.call(thisp, walker.value, i, this);
          walker = walker.prev;
        }
      };
      Yallist.prototype.get = function(n) {
        for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
          walker = walker.next;
        }
        if (i === n && walker !== null) {
          return walker.value;
        }
      };
      Yallist.prototype.getReverse = function(n) {
        for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
          walker = walker.prev;
        }
        if (i === n && walker !== null) {
          return walker.value;
        }
      };
      Yallist.prototype.map = function(fn, thisp) {
        thisp = thisp || this;
        var res = new Yallist();
        for (var walker = this.head; walker !== null; ) {
          res.push(fn.call(thisp, walker.value, this));
          walker = walker.next;
        }
        return res;
      };
      Yallist.prototype.mapReverse = function(fn, thisp) {
        thisp = thisp || this;
        var res = new Yallist();
        for (var walker = this.tail; walker !== null; ) {
          res.push(fn.call(thisp, walker.value, this));
          walker = walker.prev;
        }
        return res;
      };
      Yallist.prototype.reduce = function(fn, initial) {
        var acc;
        var walker = this.head;
        if (arguments.length > 1) {
          acc = initial;
        } else if (this.head) {
          walker = this.head.next;
          acc = this.head.value;
        } else {
          throw new TypeError("Reduce of empty list with no initial value");
        }
        for (var i = 0; walker !== null; i++) {
          acc = fn(acc, walker.value, i);
          walker = walker.next;
        }
        return acc;
      };
      Yallist.prototype.reduceReverse = function(fn, initial) {
        var acc;
        var walker = this.tail;
        if (arguments.length > 1) {
          acc = initial;
        } else if (this.tail) {
          walker = this.tail.prev;
          acc = this.tail.value;
        } else {
          throw new TypeError("Reduce of empty list with no initial value");
        }
        for (var i = this.length - 1; walker !== null; i--) {
          acc = fn(acc, walker.value, i);
          walker = walker.prev;
        }
        return acc;
      };
      Yallist.prototype.toArray = function() {
        var arr = new Array(this.length);
        for (var i = 0, walker = this.head; walker !== null; i++) {
          arr[i] = walker.value;
          walker = walker.next;
        }
        return arr;
      };
      Yallist.prototype.toArrayReverse = function() {
        var arr = new Array(this.length);
        for (var i = 0, walker = this.tail; walker !== null; i++) {
          arr[i] = walker.value;
          walker = walker.prev;
        }
        return arr;
      };
      Yallist.prototype.slice = function(from, to) {
        to = to || this.length;
        if (to < 0) {
          to += this.length;
        }
        from = from || 0;
        if (from < 0) {
          from += this.length;
        }
        var ret = new Yallist();
        if (to < from || to < 0) {
          return ret;
        }
        if (from < 0) {
          from = 0;
        }
        if (to > this.length) {
          to = this.length;
        }
        for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
          walker = walker.next;
        }
        for (; walker !== null && i < to; i++, walker = walker.next) {
          ret.push(walker.value);
        }
        return ret;
      };
      Yallist.prototype.sliceReverse = function(from, to) {
        to = to || this.length;
        if (to < 0) {
          to += this.length;
        }
        from = from || 0;
        if (from < 0) {
          from += this.length;
        }
        var ret = new Yallist();
        if (to < from || to < 0) {
          return ret;
        }
        if (from < 0) {
          from = 0;
        }
        if (to > this.length) {
          to = this.length;
        }
        for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
          walker = walker.prev;
        }
        for (; walker !== null && i > from; i--, walker = walker.prev) {
          ret.push(walker.value);
        }
        return ret;
      };
      Yallist.prototype.splice = function(start3, deleteCount, ...nodes) {
        if (start3 > this.length) {
          start3 = this.length - 1;
        }
        if (start3 < 0) {
          start3 = this.length + start3;
        }
        for (var i = 0, walker = this.head; walker !== null && i < start3; i++) {
          walker = walker.next;
        }
        var ret = [];
        for (var i = 0; walker && i < deleteCount; i++) {
          ret.push(walker.value);
          walker = this.removeNode(walker);
        }
        if (walker === null) {
          walker = this.tail;
        }
        if (walker !== this.head && walker !== this.tail) {
          walker = walker.prev;
        }
        for (var i = 0; i < nodes.length; i++) {
          walker = insert(this, walker, nodes[i]);
        }
        return ret;
      };
      Yallist.prototype.reverse = function() {
        var head = this.head;
        var tail = this.tail;
        for (var walker = head; walker !== null; walker = walker.prev) {
          var p = walker.prev;
          walker.prev = walker.next;
          walker.next = p;
        }
        this.head = tail;
        this.tail = head;
        return this;
      };
      function insert(self2, node2, value2) {
        var inserted = node2 === self2.head ? new Node5(value2, null, node2, self2) : new Node5(value2, node2, node2.next, self2);
        if (inserted.next === null) {
          self2.tail = inserted;
        }
        if (inserted.prev === null) {
          self2.head = inserted;
        }
        self2.length++;
        return inserted;
      }
      function push3(self2, item) {
        self2.tail = new Node5(item, self2.tail, null, self2);
        if (!self2.head) {
          self2.head = self2.tail;
        }
        self2.length++;
      }
      function unshift(self2, item) {
        self2.head = new Node5(item, null, self2.head, self2);
        if (!self2.tail) {
          self2.tail = self2.head;
        }
        self2.length++;
      }
      function Node5(value2, prev, next, list3) {
        if (!(this instanceof Node5)) {
          return new Node5(value2, prev, next, list3);
        }
        this.list = list3;
        this.value = value2;
        if (prev) {
          prev.next = this;
          this.prev = prev;
        } else {
          this.prev = null;
        }
        if (next) {
          next.prev = this;
          this.next = next;
        } else {
          this.next = null;
        }
      }
      try {
        requireIterator()(Yallist);
      } catch (er) {
      }
      return yallist;
    }
    var lruCache;
    var hasRequiredLruCache;
    function requireLruCache() {
      if (hasRequiredLruCache)
        return lruCache;
      hasRequiredLruCache = 1;
      const Yallist = requireYallist();
      const MAX = Symbol("max");
      const LENGTH = Symbol("length");
      const LENGTH_CALCULATOR = Symbol("lengthCalculator");
      const ALLOW_STALE = Symbol("allowStale");
      const MAX_AGE = Symbol("maxAge");
      const DISPOSE = Symbol("dispose");
      const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
      const LRU_LIST = Symbol("lruList");
      const CACHE = Symbol("cache");
      const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
      const naiveLength = () => 1;
      class LRUCache {
        constructor(options) {
          if (typeof options === "number")
            options = {
              max: options
            };
          if (!options)
            options = {};
          if (options.max && (typeof options.max !== "number" || options.max < 0))
            throw new TypeError("max must be a non-negative number");
          this[MAX] = options.max || Infinity;
          const lc = options.length || naiveLength;
          this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
          this[ALLOW_STALE] = options.stale || false;
          if (options.maxAge && typeof options.maxAge !== "number")
            throw new TypeError("maxAge must be a number");
          this[MAX_AGE] = options.maxAge || 0;
          this[DISPOSE] = options.dispose;
          this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
          this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
          this.reset();
        }
        set max(mL) {
          if (typeof mL !== "number" || mL < 0)
            throw new TypeError("max must be a non-negative number");
          this[MAX] = mL || Infinity;
          trim(this);
        }
        get max() {
          return this[MAX];
        }
        set allowStale(allowStale) {
          this[ALLOW_STALE] = !!allowStale;
        }
        get allowStale() {
          return this[ALLOW_STALE];
        }
        set maxAge(mA) {
          if (typeof mA !== "number")
            throw new TypeError("maxAge must be a non-negative number");
          this[MAX_AGE] = mA;
          trim(this);
        }
        get maxAge() {
          return this[MAX_AGE];
        }
        set lengthCalculator(lC) {
          if (typeof lC !== "function")
            lC = naiveLength;
          if (lC !== this[LENGTH_CALCULATOR]) {
            this[LENGTH_CALCULATOR] = lC;
            this[LENGTH] = 0;
            this[LRU_LIST].forEach((hit) => {
              hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
              this[LENGTH] += hit.length;
            });
          }
          trim(this);
        }
        get lengthCalculator() {
          return this[LENGTH_CALCULATOR];
        }
        get length() {
          return this[LENGTH];
        }
        get itemCount() {
          return this[LRU_LIST].length;
        }
        rforEach(fn, thisp) {
          thisp = thisp || this;
          for (let walker = this[LRU_LIST].tail; walker !== null; ) {
            const prev = walker.prev;
            forEachStep(this, fn, walker, thisp);
            walker = prev;
          }
        }
        forEach(fn, thisp) {
          thisp = thisp || this;
          for (let walker = this[LRU_LIST].head; walker !== null; ) {
            const next = walker.next;
            forEachStep(this, fn, walker, thisp);
            walker = next;
          }
        }
        keys() {
          return this[LRU_LIST].toArray().map((k) => k.key);
        }
        values() {
          return this[LRU_LIST].toArray().map((k) => k.value);
        }
        reset() {
          if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
            this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
          }
          this[CACHE] = /* @__PURE__ */ new Map();
          this[LRU_LIST] = new Yallist();
          this[LENGTH] = 0;
        }
        dump() {
          return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
            k: hit.key,
            v: hit.value,
            e: hit.now + (hit.maxAge || 0)
          }).toArray().filter((h) => h);
        }
        dumpLru() {
          return this[LRU_LIST];
        }
        set(key2, value2, maxAge) {
          maxAge = maxAge || this[MAX_AGE];
          if (maxAge && typeof maxAge !== "number")
            throw new TypeError("maxAge must be a number");
          const now = maxAge ? Date.now() : 0;
          const len = this[LENGTH_CALCULATOR](value2, key2);
          if (this[CACHE].has(key2)) {
            if (len > this[MAX]) {
              del(this, this[CACHE].get(key2));
              return false;
            }
            const node2 = this[CACHE].get(key2);
            const item = node2.value;
            if (this[DISPOSE]) {
              if (!this[NO_DISPOSE_ON_SET])
                this[DISPOSE](key2, item.value);
            }
            item.now = now;
            item.maxAge = maxAge;
            item.value = value2;
            this[LENGTH] += len - item.length;
            item.length = len;
            this.get(key2);
            trim(this);
            return true;
          }
          const hit = new Entry(key2, value2, len, now, maxAge);
          if (hit.length > this[MAX]) {
            if (this[DISPOSE])
              this[DISPOSE](key2, value2);
            return false;
          }
          this[LENGTH] += hit.length;
          this[LRU_LIST].unshift(hit);
          this[CACHE].set(key2, this[LRU_LIST].head);
          trim(this);
          return true;
        }
        has(key2) {
          if (!this[CACHE].has(key2))
            return false;
          const hit = this[CACHE].get(key2).value;
          return !isStale(this, hit);
        }
        get(key2) {
          return get(this, key2, true);
        }
        peek(key2) {
          return get(this, key2, false);
        }
        pop() {
          const node2 = this[LRU_LIST].tail;
          if (!node2)
            return null;
          del(this, node2);
          return node2.value;
        }
        del(key2) {
          del(this, this[CACHE].get(key2));
        }
        load(arr) {
          this.reset();
          const now = Date.now();
          for (let l = arr.length - 1; l >= 0; l--) {
            const hit = arr[l];
            const expiresAt = hit.e || 0;
            if (expiresAt === 0)
              this.set(hit.k, hit.v);
            else {
              const maxAge = expiresAt - now;
              if (maxAge > 0) {
                this.set(hit.k, hit.v, maxAge);
              }
            }
          }
        }
        prune() {
          this[CACHE].forEach((value2, key2) => get(this, key2, false));
        }
      }
      const get = (self2, key2, doUse) => {
        const node2 = self2[CACHE].get(key2);
        if (node2) {
          const hit = node2.value;
          if (isStale(self2, hit)) {
            del(self2, node2);
            if (!self2[ALLOW_STALE])
              return void 0;
          } else {
            if (doUse) {
              if (self2[UPDATE_AGE_ON_GET])
                node2.value.now = Date.now();
              self2[LRU_LIST].unshiftNode(node2);
            }
          }
          return hit.value;
        }
      };
      const isStale = (self2, hit) => {
        if (!hit || !hit.maxAge && !self2[MAX_AGE])
          return false;
        const diff2 = Date.now() - hit.now;
        return hit.maxAge ? diff2 > hit.maxAge : self2[MAX_AGE] && diff2 > self2[MAX_AGE];
      };
      const trim = (self2) => {
        if (self2[LENGTH] > self2[MAX]) {
          for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
            const prev = walker.prev;
            del(self2, walker);
            walker = prev;
          }
        }
      };
      const del = (self2, node2) => {
        if (node2) {
          const hit = node2.value;
          if (self2[DISPOSE])
            self2[DISPOSE](hit.key, hit.value);
          self2[LENGTH] -= hit.length;
          self2[CACHE].delete(hit.key);
          self2[LRU_LIST].removeNode(node2);
        }
      };
      class Entry {
        constructor(key2, value2, length, now, maxAge) {
          this.key = key2;
          this.value = value2;
          this.length = length;
          this.now = now;
          this.maxAge = maxAge || 0;
        }
      }
      const forEachStep = (self2, fn, node2, thisp) => {
        let hit = node2.value;
        if (isStale(self2, hit)) {
          del(self2, node2);
          if (!self2[ALLOW_STALE])
            hit = void 0;
        }
        if (hit)
          fn.call(thisp, hit.value, hit.key, self2);
      };
      lruCache = LRUCache;
      return lruCache;
    }
    var range;
    var hasRequiredRange;
    function requireRange() {
      if (hasRequiredRange)
        return range;
      hasRequiredRange = 1;
      class Range2 {
        constructor(range2, options) {
          options = parseOptions2(options);
          if (range2 instanceof Range2) {
            if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
              return range2;
            } else {
              return new Range2(range2.raw, options);
            }
          }
          if (range2 instanceof Comparator2) {
            this.raw = range2.value;
            this.set = [[range2]];
            this.format();
            return this;
          }
          this.options = options;
          this.loose = !!options.loose;
          this.includePrerelease = !!options.includePrerelease;
          this.raw = range2;
          this.set = range2.split("||").map((r) => this.parseRange(r.trim())).filter((c2) => c2.length);
          if (!this.set.length) {
            throw new TypeError(`Invalid SemVer Range: ${range2}`);
          }
          if (this.set.length > 1) {
            const first = this.set[0];
            this.set = this.set.filter((c2) => !isNullSet(c2[0]));
            if (this.set.length === 0) {
              this.set = [first];
            } else if (this.set.length > 1) {
              for (const c2 of this.set) {
                if (c2.length === 1 && isAny(c2[0])) {
                  this.set = [c2];
                  break;
                }
              }
            }
          }
          this.format();
        }
        format() {
          this.range = this.set.map((comps) => {
            return comps.join(" ").trim();
          }).join("||").trim();
          return this.range;
        }
        toString() {
          return this.range;
        }
        parseRange(range2) {
          range2 = range2.trim();
          const memoOpts = Object.keys(this.options).join(",");
          const memoKey = `parseRange:${memoOpts}:${range2}`;
          const cached = cache.get(memoKey);
          if (cached) {
            return cached;
          }
          const loose = this.options.loose;
          const hr = loose ? re2[t4.HYPHENRANGELOOSE] : re2[t4.HYPHENRANGE];
          range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
          debug2("hyphen replace", range2);
          range2 = range2.replace(re2[t4.COMPARATORTRIM], comparatorTrimReplace);
          debug2("comparator trim", range2);
          range2 = range2.replace(re2[t4.TILDETRIM], tildeTrimReplace);
          range2 = range2.replace(re2[t4.CARETTRIM], caretTrimReplace);
          range2 = range2.split(/\s+/).join(" ");
          let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
          if (loose) {
            rangeList = rangeList.filter((comp) => {
              debug2("loose invalid filter", comp, this.options);
              return !!comp.match(re2[t4.COMPARATORLOOSE]);
            });
          }
          debug2("range list", rangeList);
          const rangeMap = /* @__PURE__ */ new Map();
          const comparators = rangeList.map((comp) => new Comparator2(comp, this.options));
          for (const comp of comparators) {
            if (isNullSet(comp)) {
              return [comp];
            }
            rangeMap.set(comp.value, comp);
          }
          if (rangeMap.size > 1 && rangeMap.has("")) {
            rangeMap.delete("");
          }
          const result = [...rangeMap.values()];
          cache.set(memoKey, result);
          return result;
        }
        intersects(range2, options) {
          if (!(range2 instanceof Range2)) {
            throw new TypeError("a Range is required");
          }
          return this.set.some((thisComparators) => {
            return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => {
              return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
                return rangeComparators.every((rangeComparator) => {
                  return thisComparator.intersects(rangeComparator, options);
                });
              });
            });
          });
        }
        test(version3) {
          if (!version3) {
            return false;
          }
          if (typeof version3 === "string") {
            try {
              version3 = new SemVer2(version3, this.options);
            } catch (er) {
              return false;
            }
          }
          for (let i = 0; i < this.set.length; i++) {
            if (testSet(this.set[i], version3, this.options)) {
              return true;
            }
          }
          return false;
        }
      }
      range = Range2;
      const LRU = requireLruCache();
      const cache = new LRU({
        max: 1e3
      });
      const parseOptions2 = parseOptions_1;
      const Comparator2 = requireComparator();
      const debug2 = debug_1;
      const SemVer2 = semver$2;
      const {
        re: re2,
        t: t4,
        comparatorTrimReplace,
        tildeTrimReplace,
        caretTrimReplace
      } = re$3.exports;
      const isNullSet = (c2) => c2.value === "<0.0.0-0";
      const isAny = (c2) => c2.value === "";
      const isSatisfiable = (comparators, options) => {
        let result = true;
        const remainingComparators = comparators.slice();
        let testComparator = remainingComparators.pop();
        while (result && remainingComparators.length) {
          result = remainingComparators.every((otherComparator) => {
            return testComparator.intersects(otherComparator, options);
          });
          testComparator = remainingComparators.pop();
        }
        return result;
      };
      const parseComparator = (comp, options) => {
        debug2("comp", comp, options);
        comp = replaceCarets(comp, options);
        debug2("caret", comp);
        comp = replaceTildes(comp, options);
        debug2("tildes", comp);
        comp = replaceXRanges(comp, options);
        debug2("xrange", comp);
        comp = replaceStars(comp, options);
        debug2("stars", comp);
        return comp;
      };
      const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
      const replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c2) => {
        return replaceTilde(c2, options);
      }).join(" ");
      const replaceTilde = (comp, options) => {
        const r = options.loose ? re2[t4.TILDELOOSE] : re2[t4.TILDE];
        return comp.replace(r, (_, M, m, p, pr) => {
          debug2("tilde", comp, _, M, m, p, pr);
          let ret;
          if (isX(M)) {
            ret = "";
          } else if (isX(m)) {
            ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
          } else if (isX(p)) {
            ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
          } else if (pr) {
            debug2("replaceTilde pr", pr);
            ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
          } else {
            ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
          }
          debug2("tilde return", ret);
          return ret;
        });
      };
      const replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c2) => {
        return replaceCaret(c2, options);
      }).join(" ");
      const replaceCaret = (comp, options) => {
        debug2("caret", comp, options);
        const r = options.loose ? re2[t4.CARETLOOSE] : re2[t4.CARET];
        const z = options.includePrerelease ? "-0" : "";
        return comp.replace(r, (_, M, m, p, pr) => {
          debug2("caret", comp, _, M, m, p, pr);
          let ret;
          if (isX(M)) {
            ret = "";
          } else if (isX(m)) {
            ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
          } else if (isX(p)) {
            if (M === "0") {
              ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
            } else {
              ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
            }
          } else if (pr) {
            debug2("replaceCaret pr", pr);
            if (M === "0") {
              if (m === "0") {
                ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
              } else {
                ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
              }
            } else {
              ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
            }
          } else {
            debug2("no pr");
            if (M === "0") {
              if (m === "0") {
                ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
              } else {
                ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
              }
            } else {
              ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
            }
          }
          debug2("caret return", ret);
          return ret;
        });
      };
      const replaceXRanges = (comp, options) => {
        debug2("replaceXRanges", comp, options);
        return comp.split(/\s+/).map((c2) => {
          return replaceXRange(c2, options);
        }).join(" ");
      };
      const replaceXRange = (comp, options) => {
        comp = comp.trim();
        const r = options.loose ? re2[t4.XRANGELOOSE] : re2[t4.XRANGE];
        return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
          debug2("xRange", comp, ret, gtlt, M, m, p, pr);
          const xM = isX(M);
          const xm = xM || isX(m);
          const xp = xm || isX(p);
          const anyX = xp;
          if (gtlt === "=" && anyX) {
            gtlt = "";
          }
          pr = options.includePrerelease ? "-0" : "";
          if (xM) {
            if (gtlt === ">" || gtlt === "<") {
              ret = "<0.0.0-0";
            } else {
              ret = "*";
            }
          } else if (gtlt && anyX) {
            if (xm) {
              m = 0;
            }
            p = 0;
            if (gtlt === ">") {
              gtlt = ">=";
              if (xm) {
                M = +M + 1;
                m = 0;
                p = 0;
              } else {
                m = +m + 1;
                p = 0;
              }
            } else if (gtlt === "<=") {
              gtlt = "<";
              if (xm) {
                M = +M + 1;
              } else {
                m = +m + 1;
              }
            }
            if (gtlt === "<") {
              pr = "-0";
            }
            ret = `${gtlt + M}.${m}.${p}${pr}`;
          } else if (xm) {
            ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
          } else if (xp) {
            ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
          }
          debug2("xRange return", ret);
          return ret;
        });
      };
      const replaceStars = (comp, options) => {
        debug2("replaceStars", comp, options);
        return comp.trim().replace(re2[t4.STAR], "");
      };
      const replaceGTE0 = (comp, options) => {
        debug2("replaceGTE0", comp, options);
        return comp.trim().replace(re2[options.includePrerelease ? t4.GTE0PRE : t4.GTE0], "");
      };
      const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
        if (isX(fM)) {
          from = "";
        } else if (isX(fm)) {
          from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
        } else if (isX(fp)) {
          from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
        } else if (fpr) {
          from = `>=${from}`;
        } else {
          from = `>=${from}${incPr ? "-0" : ""}`;
        }
        if (isX(tM)) {
          to = "";
        } else if (isX(tm)) {
          to = `<${+tM + 1}.0.0-0`;
        } else if (isX(tp)) {
          to = `<${tM}.${+tm + 1}.0-0`;
        } else if (tpr) {
          to = `<=${tM}.${tm}.${tp}-${tpr}`;
        } else if (incPr) {
          to = `<${tM}.${tm}.${+tp + 1}-0`;
        } else {
          to = `<=${to}`;
        }
        return `${from} ${to}`.trim();
      };
      const testSet = (set, version3, options) => {
        for (let i = 0; i < set.length; i++) {
          if (!set[i].test(version3)) {
            return false;
          }
        }
        if (version3.prerelease.length && !options.includePrerelease) {
          for (let i = 0; i < set.length; i++) {
            debug2(set[i].semver);
            if (set[i].semver === Comparator2.ANY) {
              continue;
            }
            if (set[i].semver.prerelease.length > 0) {
              const allowed = set[i].semver;
              if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
                return true;
              }
            }
          }
          return false;
        }
        return true;
      };
      return range;
    }
    var comparator;
    var hasRequiredComparator;
    function requireComparator() {
      if (hasRequiredComparator)
        return comparator;
      hasRequiredComparator = 1;
      const ANY2 = Symbol("SemVer ANY");
      class Comparator2 {
        static get ANY() {
          return ANY2;
        }
        constructor(comp, options) {
          options = parseOptions2(options);
          if (comp instanceof Comparator2) {
            if (comp.loose === !!options.loose) {
              return comp;
            } else {
              comp = comp.value;
            }
          }
          debug2("comparator", comp, options);
          this.options = options;
          this.loose = !!options.loose;
          this.parse(comp);
          if (this.semver === ANY2) {
            this.value = "";
          } else {
            this.value = this.operator + this.semver.version;
          }
          debug2("comp", this);
        }
        parse(comp) {
          const r = this.options.loose ? re2[t4.COMPARATORLOOSE] : re2[t4.COMPARATOR];
          const m = comp.match(r);
          if (!m) {
            throw new TypeError(`Invalid comparator: ${comp}`);
          }
          this.operator = m[1] !== void 0 ? m[1] : "";
          if (this.operator === "=") {
            this.operator = "";
          }
          if (!m[2]) {
            this.semver = ANY2;
          } else {
            this.semver = new SemVer2(m[2], this.options.loose);
          }
        }
        toString() {
          return this.value;
        }
        test(version3) {
          debug2("Comparator.test", version3, this.options.loose);
          if (this.semver === ANY2 || version3 === ANY2) {
            return true;
          }
          if (typeof version3 === "string") {
            try {
              version3 = new SemVer2(version3, this.options);
            } catch (er) {
              return false;
            }
          }
          return cmp2(version3, this.operator, this.semver, this.options);
        }
        intersects(comp, options) {
          if (!(comp instanceof Comparator2)) {
            throw new TypeError("a Comparator is required");
          }
          if (!options || typeof options !== "object") {
            options = {
              loose: !!options,
              includePrerelease: false
            };
          }
          if (this.operator === "") {
            if (this.value === "") {
              return true;
            }
            return new Range2(comp.value, options).test(this.value);
          } else if (comp.operator === "") {
            if (comp.value === "") {
              return true;
            }
            return new Range2(this.value, options).test(comp.semver);
          }
          const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
          const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
          const sameSemVer = this.semver.version === comp.semver.version;
          const differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
          const oppositeDirectionsLessThan = cmp2(this.semver, "<", comp.semver, options) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
          const oppositeDirectionsGreaterThan = cmp2(this.semver, ">", comp.semver, options) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
          return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
        }
      }
      comparator = Comparator2;
      const parseOptions2 = parseOptions_1;
      const {
        re: re2,
        t: t4
      } = re$3.exports;
      const cmp2 = cmp_1;
      const debug2 = debug_1;
      const SemVer2 = semver$2;
      const Range2 = requireRange();
      return comparator;
    }
    var Range$8 = requireRange();
    var satisfies$3 = (version3, range2, options) => {
      try {
        range2 = new Range$8(range2, options);
      } catch (er) {
        return false;
      }
      return range2.test(version3);
    };
    var satisfies_1 = satisfies$3;
    var Range$7 = requireRange();
    var toComparators = (range2, options) => new Range$7(range2, options).set.map((comp) => comp.map((c2) => c2.value).join(" ").trim().split(" "));
    var toComparators_1 = toComparators;
    var SemVer$3 = semver$2;
    var Range$6 = requireRange();
    var maxSatisfying = (versions, range2, options) => {
      let max = null;
      let maxSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range$6(range2, options);
      } catch (er) {
        return null;
      }
      versions.forEach((v) => {
        if (rangeObj.test(v)) {
          if (!max || maxSV.compare(v) === -1) {
            max = v;
            maxSV = new SemVer$3(max, options);
          }
        }
      });
      return max;
    };
    var maxSatisfying_1 = maxSatisfying;
    var SemVer$2 = semver$2;
    var Range$5 = requireRange();
    var minSatisfying = (versions, range2, options) => {
      let min = null;
      let minSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range$5(range2, options);
      } catch (er) {
        return null;
      }
      versions.forEach((v) => {
        if (rangeObj.test(v)) {
          if (!min || minSV.compare(v) === 1) {
            min = v;
            minSV = new SemVer$2(min, options);
          }
        }
      });
      return min;
    };
    var minSatisfying_1 = minSatisfying;
    var SemVer$1 = semver$2;
    var Range$4 = requireRange();
    var gt$1 = gt_1;
    var minVersion = (range2, loose) => {
      range2 = new Range$4(range2, loose);
      let minver = new SemVer$1("0.0.0");
      if (range2.test(minver)) {
        return minver;
      }
      minver = new SemVer$1("0.0.0-0");
      if (range2.test(minver)) {
        return minver;
      }
      minver = null;
      for (let i = 0; i < range2.set.length; ++i) {
        const comparators = range2.set[i];
        let setMin = null;
        comparators.forEach((comparator2) => {
          const compver = new SemVer$1(comparator2.semver.version);
          switch (comparator2.operator) {
            case ">":
              if (compver.prerelease.length === 0) {
                compver.patch++;
              } else {
                compver.prerelease.push(0);
              }
              compver.raw = compver.format();
            case "":
            case ">=":
              if (!setMin || gt$1(compver, setMin)) {
                setMin = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            default:
              throw new Error(`Unexpected operation: ${comparator2.operator}`);
          }
        });
        if (setMin && (!minver || gt$1(minver, setMin))) {
          minver = setMin;
        }
      }
      if (minver && range2.test(minver)) {
        return minver;
      }
      return null;
    };
    var minVersion_1 = minVersion;
    var Range$3 = requireRange();
    var validRange = (range2, options) => {
      try {
        return new Range$3(range2, options).range || "*";
      } catch (er) {
        return null;
      }
    };
    var valid2 = validRange;
    var SemVer = semver$2;
    var Comparator$1 = requireComparator();
    var {
      ANY: ANY$1
    } = Comparator$1;
    var Range$2 = requireRange();
    var satisfies$2 = satisfies_1;
    var gt = gt_1;
    var lt = lt_1;
    var lte = lte_1;
    var gte = gte_1;
    var outside$2 = (version3, range2, hilo, options) => {
      version3 = new SemVer(version3, options);
      range2 = new Range$2(range2, options);
      let gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt;
          ltefn = lte;
          ltfn = lt;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt;
          ltefn = gte;
          ltfn = gt;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies$2(version3, range2, options)) {
        return false;
      }
      for (let i = 0; i < range2.set.length; ++i) {
        const comparators = range2.set[i];
        let high = null;
        let low = null;
        comparators.forEach((comparator2) => {
          if (comparator2.semver === ANY$1) {
            comparator2 = new Comparator$1(">=0.0.0");
          }
          high = high || comparator2;
          low = low || comparator2;
          if (gtfn(comparator2.semver, high.semver, options)) {
            high = comparator2;
          } else if (ltfn(comparator2.semver, low.semver, options)) {
            low = comparator2;
          }
        });
        if (high.operator === comp || high.operator === ecomp) {
          return false;
        }
        if ((!low.operator || low.operator === comp) && ltefn(version3, low.semver)) {
          return false;
        } else if (low.operator === ecomp && ltfn(version3, low.semver)) {
          return false;
        }
      }
      return true;
    };
    var outside_1 = outside$2;
    var outside$1 = outside_1;
    var gtr = (version3, range2, options) => outside$1(version3, range2, ">", options);
    var gtr_1 = gtr;
    var outside = outside_1;
    var ltr = (version3, range2, options) => outside(version3, range2, "<", options);
    var ltr_1 = ltr;
    var Range$1 = requireRange();
    var intersects = (r1, r2, options) => {
      r1 = new Range$1(r1, options);
      r2 = new Range$1(r2, options);
      return r1.intersects(r2);
    };
    var intersects_1 = intersects;
    var satisfies$1 = satisfies_1;
    var compare$1 = compare_1;
    var simplify = (versions, range2, options) => {
      const set = [];
      let first = null;
      let prev = null;
      const v = versions.sort((a, b) => compare$1(a, b, options));
      for (const version3 of v) {
        const included = satisfies$1(version3, range2, options);
        if (included) {
          prev = version3;
          if (!first) {
            first = version3;
          }
        } else {
          if (prev) {
            set.push([first, prev]);
          }
          prev = null;
          first = null;
        }
      }
      if (first) {
        set.push([first, null]);
      }
      const ranges = [];
      for (const [min, max] of set) {
        if (min === max) {
          ranges.push(min);
        } else if (!max && min === v[0]) {
          ranges.push("*");
        } else if (!max) {
          ranges.push(`>=${min}`);
        } else if (min === v[0]) {
          ranges.push(`<=${max}`);
        } else {
          ranges.push(`${min} - ${max}`);
        }
      }
      const simplified = ranges.join(" || ");
      const original = typeof range2.raw === "string" ? range2.raw : String(range2);
      return simplified.length < original.length ? simplified : range2;
    };
    var Range = requireRange();
    var Comparator = requireComparator();
    var {
      ANY
    } = Comparator;
    var satisfies = satisfies_1;
    var compare2 = compare_1;
    var subset = (sub, dom, options = {}) => {
      if (sub === dom) {
        return true;
      }
      sub = new Range(sub, options);
      dom = new Range(dom, options);
      let sawNonNull = false;
      OUTER:
        for (const simpleSub of sub.set) {
          for (const simpleDom of dom.set) {
            const isSub = simpleSubset(simpleSub, simpleDom, options);
            sawNonNull = sawNonNull || isSub !== null;
            if (isSub) {
              continue OUTER;
            }
          }
          if (sawNonNull) {
            return false;
          }
        }
      return true;
    };
    var simpleSubset = (sub, dom, options) => {
      if (sub === dom) {
        return true;
      }
      if (sub.length === 1 && sub[0].semver === ANY) {
        if (dom.length === 1 && dom[0].semver === ANY) {
          return true;
        } else if (options.includePrerelease) {
          sub = [new Comparator(">=0.0.0-0")];
        } else {
          sub = [new Comparator(">=0.0.0")];
        }
      }
      if (dom.length === 1 && dom[0].semver === ANY) {
        if (options.includePrerelease) {
          return true;
        } else {
          dom = [new Comparator(">=0.0.0")];
        }
      }
      const eqSet = /* @__PURE__ */ new Set();
      let gt2, lt2;
      for (const c2 of sub) {
        if (c2.operator === ">" || c2.operator === ">=") {
          gt2 = higherGT(gt2, c2, options);
        } else if (c2.operator === "<" || c2.operator === "<=") {
          lt2 = lowerLT(lt2, c2, options);
        } else {
          eqSet.add(c2.semver);
        }
      }
      if (eqSet.size > 1) {
        return null;
      }
      let gtltComp;
      if (gt2 && lt2) {
        gtltComp = compare2(gt2.semver, lt2.semver, options);
        if (gtltComp > 0) {
          return null;
        } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) {
          return null;
        }
      }
      for (const eq2 of eqSet) {
        if (gt2 && !satisfies(eq2, String(gt2), options)) {
          return null;
        }
        if (lt2 && !satisfies(eq2, String(lt2), options)) {
          return null;
        }
        for (const c2 of dom) {
          if (!satisfies(eq2, String(c2), options)) {
            return false;
          }
        }
        return true;
      }
      let higher, lower;
      let hasDomLT, hasDomGT;
      let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
      let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false;
      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) {
        needDomLTPre = false;
      }
      for (const c2 of dom) {
        hasDomGT = hasDomGT || c2.operator === ">" || c2.operator === ">=";
        hasDomLT = hasDomLT || c2.operator === "<" || c2.operator === "<=";
        if (gt2) {
          if (needDomGTPre) {
            if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomGTPre.major && c2.semver.minor === needDomGTPre.minor && c2.semver.patch === needDomGTPre.patch) {
              needDomGTPre = false;
            }
          }
          if (c2.operator === ">" || c2.operator === ">=") {
            higher = higherGT(gt2, c2, options);
            if (higher === c2 && higher !== gt2) {
              return false;
            }
          } else if (gt2.operator === ">=" && !satisfies(gt2.semver, String(c2), options)) {
            return false;
          }
        }
        if (lt2) {
          if (needDomLTPre) {
            if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomLTPre.major && c2.semver.minor === needDomLTPre.minor && c2.semver.patch === needDomLTPre.patch) {
              needDomLTPre = false;
            }
          }
          if (c2.operator === "<" || c2.operator === "<=") {
            lower = lowerLT(lt2, c2, options);
            if (lower === c2 && lower !== lt2) {
              return false;
            }
          } else if (lt2.operator === "<=" && !satisfies(lt2.semver, String(c2), options)) {
            return false;
          }
        }
        if (!c2.operator && (lt2 || gt2) && gtltComp !== 0) {
          return false;
        }
      }
      if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) {
        return false;
      }
      if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) {
        return false;
      }
      if (needDomGTPre || needDomLTPre) {
        return false;
      }
      return true;
    };
    var higherGT = (a, b, options) => {
      if (!a) {
        return b;
      }
      const comp = compare2(a.semver, b.semver, options);
      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
    };
    var lowerLT = (a, b, options) => {
      if (!a) {
        return b;
      }
      const comp = compare2(a.semver, b.semver, options);
      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
    };
    var subset_1 = subset;
    var internalRe = re$3.exports;
    var semver$1 = {
      re: internalRe.re,
      src: internalRe.src,
      tokens: internalRe.t,
      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
      SemVer: semver$2,
      compareIdentifiers: identifiers.compareIdentifiers,
      rcompareIdentifiers: identifiers.rcompareIdentifiers,
      parse: parse_1,
      valid: valid_1,
      clean: clean_1,
      inc: inc_1,
      diff: diff_1,
      major: major_1,
      minor: minor_1,
      patch: patch_1,
      prerelease: prerelease_1,
      compare: compare_1,
      rcompare: rcompare_1,
      compareLoose: compareLoose_1,
      compareBuild: compareBuild_1,
      sort: sort_1,
      rsort: rsort_1,
      gt: gt_1,
      lt: lt_1,
      eq: eq_1,
      neq: neq_1,
      gte: gte_1,
      lte: lte_1,
      cmp: cmp_1,
      coerce: coerce_1,
      Comparator: requireComparator(),
      Range: requireRange(),
      satisfies: satisfies_1,
      toComparators: toComparators_1,
      maxSatisfying: maxSatisfying_1,
      minSatisfying: minSatisfying_1,
      minVersion: minVersion_1,
      validRange: valid2,
      outside: outside_1,
      gtr: gtr_1,
      ltr: ltr_1,
      intersects: intersects_1,
      simplifyRange: simplify,
      subset: subset_1
    };
    var semver = semver$1;
    var builtins = function({
      version: version3 = process.version,
      experimental = false
    } = {}) {
      var coreModules = ["assert", "buffer", "child_process", "cluster", "console", "constants", "crypto", "dgram", "dns", "domain", "events", "fs", "http", "https", "module", "net", "os", "path", "punycode", "querystring", "readline", "repl", "stream", "string_decoder", "sys", "timers", "tls", "tty", "url", "util", "vm", "zlib"];
      if (semver.lt(version3, "6.0.0"))
        coreModules.push("freelist");
      if (semver.gte(version3, "1.0.0"))
        coreModules.push("v8");
      if (semver.gte(version3, "1.1.0"))
        coreModules.push("process");
      if (semver.gte(version3, "8.0.0"))
        coreModules.push("inspector");
      if (semver.gte(version3, "8.1.0"))
        coreModules.push("async_hooks");
      if (semver.gte(version3, "8.4.0"))
        coreModules.push("http2");
      if (semver.gte(version3, "8.5.0"))
        coreModules.push("perf_hooks");
      if (semver.gte(version3, "10.0.0"))
        coreModules.push("trace_events");
      if (semver.gte(version3, "10.5.0") && (experimental || semver.gte(version3, "12.0.0"))) {
        coreModules.push("worker_threads");
      }
      if (semver.gte(version3, "12.16.0") && experimental) {
        coreModules.push("wasi");
      }
      return coreModules;
    };
    var reader = {
      read: read2
    };
    function read2(jsonPath) {
      return find2(_path().dirname(jsonPath));
    }
    function find2(dir) {
      try {
        const string3 = _fs().default.readFileSync(_path().toNamespacedPath(_path().join(dir, "package.json")), "utf8");
        return {
          string: string3
        };
      } catch (error) {
        if (error.code === "ENOENT") {
          const parent = _path().dirname(dir);
          if (dir !== parent)
            return find2(parent);
          return {
            string: void 0
          };
        }
        throw error;
      }
    }
    var isWindows = process.platform === "win32";
    var own$1 = {}.hasOwnProperty;
    var codes = {};
    var messages2 = /* @__PURE__ */ new Map();
    var nodeInternalPrefix = "__node_internal_";
    var userStackTraceLimit;
    codes.ERR_INVALID_MODULE_SPECIFIER = createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base2 = void 0) => {
      return `Invalid module "${request}" ${reason}${base2 ? ` imported from ${base2}` : ""}`;
    }, TypeError);
    codes.ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path, base2, message) => {
      return `Invalid package config ${path}${base2 ? ` while importing ${base2}` : ""}${message ? `. ${message}` : ""}`;
    }, Error);
    codes.ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (pkgPath, key2, target, isImport = false, base2 = void 0) => {
      const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
      if (key2 === ".") {
        _assert()(isImport === false);
        return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base2 ? ` imported from ${base2}` : ""}${relError ? '; targets must start with "./"' : ""}`;
      }
      return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key2}' in the package config ${pkgPath}package.json${base2 ? ` imported from ${base2}` : ""}${relError ? '; targets must start with "./"' : ""}`;
    }, Error);
    codes.ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path, base2, type = "package") => {
      return `Cannot find ${type} '${path}' imported from ${base2}`;
    }, Error);
    codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base2) => {
      return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base2}`;
    }, TypeError);
    codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (pkgPath, subpath, base2 = void 0) => {
      if (subpath === ".")
        return `No "exports" main defined in ${pkgPath}package.json${base2 ? ` imported from ${base2}` : ""}`;
      return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base2 ? ` imported from ${base2}` : ""}`;
    }, Error);
    codes.ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
    codes.ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", 'Unknown file extension "%s" for %s', TypeError);
    codes.ERR_INVALID_ARG_VALUE = createError("ERR_INVALID_ARG_VALUE", (name2, value2, reason = "is invalid") => {
      let inspected = (0, _util().inspect)(value2);
      if (inspected.length > 128) {
        inspected = `${inspected.slice(0, 128)}...`;
      }
      const type = name2.includes(".") ? "property" : "argument";
      return `The ${type} '${name2}' ${reason}. Received ${inspected}`;
    }, TypeError);
    codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError("ERR_UNSUPPORTED_ESM_URL_SCHEME", (url) => {
      let message = "Only file and data URLs are supported by the default ESM loader";
      if (isWindows && url.protocol.length === 2) {
        message += ". On Windows, absolute paths must be valid file:// URLs";
      }
      message += `. Received protocol '${url.protocol}'`;
      return message;
    }, Error);
    function createError(sym, value2, def) {
      messages2.set(sym, value2);
      return makeNodeErrorWithCode(def, sym);
    }
    function makeNodeErrorWithCode(Base, key2) {
      return NodeError;
      function NodeError(...args) {
        const limit = Error.stackTraceLimit;
        if (isErrorStackTraceLimitWritable())
          Error.stackTraceLimit = 0;
        const error = new Base();
        if (isErrorStackTraceLimitWritable())
          Error.stackTraceLimit = limit;
        const message = getMessage(key2, args, error);
        Object.defineProperty(error, "message", {
          value: message,
          enumerable: false,
          writable: true,
          configurable: true
        });
        Object.defineProperty(error, "toString", {
          value() {
            return `${this.name} [${key2}]: ${this.message}`;
          },
          enumerable: false,
          writable: true,
          configurable: true
        });
        addCodeToName(error, Base.name, key2);
        error.code = key2;
        return error;
      }
    }
    var addCodeToName = hideStackFrames(function(error, name2, code2) {
      error = captureLargerStackTrace(error);
      error.name = `${name2} [${code2}]`;
      error.stack;
      if (name2 === "SystemError") {
        Object.defineProperty(error, "name", {
          value: name2,
          enumerable: false,
          writable: true,
          configurable: true
        });
      } else {
        delete error.name;
      }
    });
    function isErrorStackTraceLimitWritable() {
      const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
      if (desc === void 0) {
        return Object.isExtensible(Error);
      }
      return own$1.call(desc, "writable") ? desc.writable : desc.set !== void 0;
    }
    function hideStackFrames(fn) {
      const hidden = nodeInternalPrefix + fn.name;
      Object.defineProperty(fn, "name", {
        value: hidden
      });
      return fn;
    }
    var captureLargerStackTrace = hideStackFrames(function(error) {
      const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
      if (stackTraceLimitIsWritable) {
        userStackTraceLimit = Error.stackTraceLimit;
        Error.stackTraceLimit = Number.POSITIVE_INFINITY;
      }
      Error.captureStackTrace(error);
      if (stackTraceLimitIsWritable)
        Error.stackTraceLimit = userStackTraceLimit;
      return error;
    });
    function getMessage(key2, args, self2) {
      const message = messages2.get(key2);
      if (typeof message === "function") {
        _assert()(message.length <= args.length, `Code: ${key2}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`);
        return Reflect.apply(message, self2, args);
      }
      const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
      _assert()(expectedLength === args.length, `Code: ${key2}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
      if (args.length === 0)
        return message;
      args.unshift(message);
      return Reflect.apply(_util().format, null, args);
    }
    var {
      ERR_UNKNOWN_FILE_EXTENSION
    } = codes;
    var extensionFormatMap = {
      __proto__: null,
      ".cjs": "commonjs",
      ".js": "module",
      ".mjs": "module"
    };
    function defaultGetFormat(url) {
      if (url.startsWith("node:")) {
        return {
          format: "builtin"
        };
      }
      const parsed = new (_url()).URL(url);
      if (parsed.protocol === "data:") {
        const {
          1: mime
        } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [null, null];
        const format = mime === "text/javascript" ? "module" : null;
        return {
          format
        };
      }
      if (parsed.protocol === "file:") {
        const ext = _path().extname(parsed.pathname);
        let format;
        if (ext === ".js") {
          format = getPackageType(parsed.href) === "module" ? "module" : "commonjs";
        } else {
          format = extensionFormatMap[ext];
        }
        if (!format) {
          throw new ERR_UNKNOWN_FILE_EXTENSION(ext, (0, _url().fileURLToPath)(url));
        }
        return {
          format: format || null
        };
      }
      return {
        format: null
      };
    }
    var listOfBuiltins = builtins();
    var {
      ERR_INVALID_MODULE_SPECIFIER,
      ERR_INVALID_PACKAGE_CONFIG,
      ERR_INVALID_PACKAGE_TARGET,
      ERR_MODULE_NOT_FOUND,
      ERR_PACKAGE_IMPORT_NOT_DEFINED,
      ERR_PACKAGE_PATH_NOT_EXPORTED,
      ERR_UNSUPPORTED_DIR_IMPORT,
      ERR_UNSUPPORTED_ESM_URL_SCHEME,
      ERR_INVALID_ARG_VALUE
    } = codes;
    var own13 = {}.hasOwnProperty;
    var DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
    var DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
    var invalidSegmentRegEx = /(^|\\|\/)(\.\.?|node_modules)(\\|\/|$)/;
    var patternRegEx = /\*/g;
    var encodedSepRegEx = /%2f|%2c/i;
    var emittedPackageWarnings = /* @__PURE__ */ new Set();
    var packageJsonCache = /* @__PURE__ */ new Map();
    function emitFolderMapDeprecation(match, pjsonUrl, isExports, base2) {
      const pjsonPath = (0, _url().fileURLToPath)(pjsonUrl);
      if (emittedPackageWarnings.has(pjsonPath + "|" + match))
        return;
      emittedPackageWarnings.add(pjsonPath + "|" + match);
      process.emitWarning(`Use of deprecated folder mapping "${match}" in the ${isExports ? '"exports"' : '"imports"'} field module resolution of the package at ${pjsonPath}${base2 ? ` imported from ${(0, _url().fileURLToPath)(base2)}` : ""}.
Update this package.json to use a subpath pattern like "${match}*".`, "DeprecationWarning", "DEP0148");
    }
    function emitLegacyIndexDeprecation(url, packageJsonUrl, base2, main) {
      const {
        format
      } = defaultGetFormat(url.href);
      if (format !== "module")
        return;
      const path = (0, _url().fileURLToPath)(url.href);
      const pkgPath = (0, _url().fileURLToPath)(new (_url()).URL(".", packageJsonUrl));
      const basePath = (0, _url().fileURLToPath)(base2);
      if (main)
        process.emitWarning(`Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, excluding the full filename and extension to the resolved file at "${path.slice(pkgPath.length)}", imported from ${basePath}.
 Automatic extension resolution of the "main" field isdeprecated for ES modules.`, "DeprecationWarning", "DEP0151");
      else
        process.emitWarning(`No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path.slice(pkgPath.length)}", imported from ${basePath}.
Default "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
    }
    function getConditionsSet(conditions) {
      if (conditions !== void 0 && conditions !== DEFAULT_CONDITIONS) {
        if (!Array.isArray(conditions)) {
          throw new ERR_INVALID_ARG_VALUE("conditions", conditions, "expected an array");
        }
        return new Set(conditions);
      }
      return DEFAULT_CONDITIONS_SET;
    }
    function tryStatSync(path) {
      try {
        return (0, _fs().statSync)(path);
      } catch (_unused) {
        return new (_fs()).Stats();
      }
    }
    function getPackageConfig(path, specifier, base2) {
      const existing = packageJsonCache.get(path);
      if (existing !== void 0) {
        return existing;
      }
      const source2 = reader.read(path).string;
      if (source2 === void 0) {
        const packageConfig2 = {
          pjsonPath: path,
          exists: false,
          main: void 0,
          name: void 0,
          type: "none",
          exports: void 0,
          imports: void 0
        };
        packageJsonCache.set(path, packageConfig2);
        return packageConfig2;
      }
      let packageJson;
      try {
        packageJson = JSON.parse(source2);
      } catch (error) {
        throw new ERR_INVALID_PACKAGE_CONFIG(path, (base2 ? `"${specifier}" from ` : "") + (0, _url().fileURLToPath)(base2 || specifier), error.message);
      }
      const {
        exports: exports2,
        imports,
        main,
        name: name2,
        type
      } = packageJson;
      const packageConfig = {
        pjsonPath: path,
        exists: true,
        main: typeof main === "string" ? main : void 0,
        name: typeof name2 === "string" ? name2 : void 0,
        type: type === "module" || type === "commonjs" ? type : "none",
        exports: exports2,
        imports: imports && typeof imports === "object" ? imports : void 0
      };
      packageJsonCache.set(path, packageConfig);
      return packageConfig;
    }
    function getPackageScopeConfig(resolved) {
      let packageJsonUrl = new (_url()).URL("./package.json", resolved);
      while (true) {
        const packageJsonPath2 = packageJsonUrl.pathname;
        if (packageJsonPath2.endsWith("node_modules/package.json"))
          break;
        const packageConfig2 = getPackageConfig((0, _url().fileURLToPath)(packageJsonUrl), resolved);
        if (packageConfig2.exists)
          return packageConfig2;
        const lastPackageJsonUrl = packageJsonUrl;
        packageJsonUrl = new (_url()).URL("../package.json", packageJsonUrl);
        if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname)
          break;
      }
      const packageJsonPath = (0, _url().fileURLToPath)(packageJsonUrl);
      const packageConfig = {
        pjsonPath: packageJsonPath,
        exists: false,
        main: void 0,
        name: void 0,
        type: "none",
        exports: void 0,
        imports: void 0
      };
      packageJsonCache.set(packageJsonPath, packageConfig);
      return packageConfig;
    }
    function fileExists(url) {
      return tryStatSync((0, _url().fileURLToPath)(url)).isFile();
    }
    function legacyMainResolve(packageJsonUrl, packageConfig, base2) {
      let guess;
      if (packageConfig.main !== void 0) {
        guess = new (_url()).URL(`./${packageConfig.main}`, packageJsonUrl);
        if (fileExists(guess))
          return guess;
        const tries2 = [`./${packageConfig.main}.js`, `./${packageConfig.main}.json`, `./${packageConfig.main}.node`, `./${packageConfig.main}/index.js`, `./${packageConfig.main}/index.json`, `./${packageConfig.main}/index.node`];
        let i2 = -1;
        while (++i2 < tries2.length) {
          guess = new (_url()).URL(tries2[i2], packageJsonUrl);
          if (fileExists(guess))
            break;
          guess = void 0;
        }
        if (guess) {
          emitLegacyIndexDeprecation(guess, packageJsonUrl, base2, packageConfig.main);
          return guess;
        }
      }
      const tries = ["./index.js", "./index.json", "./index.node"];
      let i = -1;
      while (++i < tries.length) {
        guess = new (_url()).URL(tries[i], packageJsonUrl);
        if (fileExists(guess))
          break;
        guess = void 0;
      }
      if (guess) {
        emitLegacyIndexDeprecation(guess, packageJsonUrl, base2, packageConfig.main);
        return guess;
      }
      throw new ERR_MODULE_NOT_FOUND((0, _url().fileURLToPath)(new (_url()).URL(".", packageJsonUrl)), (0, _url().fileURLToPath)(base2));
    }
    function finalizeResolution(resolved, base2) {
      if (encodedSepRegEx.test(resolved.pathname))
        throw new ERR_INVALID_MODULE_SPECIFIER(resolved.pathname, 'must not include encoded "/" or "\\" characters', (0, _url().fileURLToPath)(base2));
      const path = (0, _url().fileURLToPath)(resolved);
      const stats = tryStatSync(path.endsWith("/") ? path.slice(-1) : path);
      if (stats.isDirectory()) {
        const error = new ERR_UNSUPPORTED_DIR_IMPORT(path, (0, _url().fileURLToPath)(base2));
        error.url = String(resolved);
        throw error;
      }
      if (!stats.isFile()) {
        throw new ERR_MODULE_NOT_FOUND(path || resolved.pathname, base2 && (0, _url().fileURLToPath)(base2), "module");
      }
      return resolved;
    }
    function throwImportNotDefined(specifier, packageJsonUrl, base2) {
      throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(specifier, packageJsonUrl && (0, _url().fileURLToPath)(new (_url()).URL(".", packageJsonUrl)), (0, _url().fileURLToPath)(base2));
    }
    function throwExportsNotFound(subpath, packageJsonUrl, base2) {
      throw new ERR_PACKAGE_PATH_NOT_EXPORTED((0, _url().fileURLToPath)(new (_url()).URL(".", packageJsonUrl)), subpath, base2 && (0, _url().fileURLToPath)(base2));
    }
    function throwInvalidSubpath(subpath, packageJsonUrl, internal, base2) {
      const reason = `request is not a valid subpath for the "${internal ? "imports" : "exports"}" resolution of ${(0, _url().fileURLToPath)(packageJsonUrl)}`;
      throw new ERR_INVALID_MODULE_SPECIFIER(subpath, reason, base2 && (0, _url().fileURLToPath)(base2));
    }
    function throwInvalidPackageTarget(subpath, target, packageJsonUrl, internal, base2) {
      target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
      throw new ERR_INVALID_PACKAGE_TARGET((0, _url().fileURLToPath)(new (_url()).URL(".", packageJsonUrl)), subpath, target, internal, base2 && (0, _url().fileURLToPath)(base2));
    }
    function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base2, pattern, internal, conditions) {
      if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
        throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base2);
      if (!target.startsWith("./")) {
        if (internal && !target.startsWith("../") && !target.startsWith("/")) {
          let isURL = false;
          try {
            new (_url()).URL(target);
            isURL = true;
          } catch (_unused2) {
          }
          if (!isURL) {
            const exportTarget = pattern ? target.replace(patternRegEx, subpath) : target + subpath;
            return packageResolve(exportTarget, packageJsonUrl, conditions);
          }
        }
        throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base2);
      }
      if (invalidSegmentRegEx.test(target.slice(2)))
        throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base2);
      const resolved = new (_url()).URL(target, packageJsonUrl);
      const resolvedPath = resolved.pathname;
      const packagePath = new (_url()).URL(".", packageJsonUrl).pathname;
      if (!resolvedPath.startsWith(packagePath))
        throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base2);
      if (subpath === "")
        return resolved;
      if (invalidSegmentRegEx.test(subpath))
        throwInvalidSubpath(match + subpath, packageJsonUrl, internal, base2);
      if (pattern)
        return new (_url()).URL(resolved.href.replace(patternRegEx, subpath));
      return new (_url()).URL(subpath, resolved);
    }
    function isArrayIndex(key2) {
      const keyNumber = Number(key2);
      if (`${keyNumber}` !== key2)
        return false;
      return keyNumber >= 0 && keyNumber < 4294967295;
    }
    function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base2, pattern, internal, conditions) {
      if (typeof target === "string") {
        return resolvePackageTargetString(target, subpath, packageSubpath, packageJsonUrl, base2, pattern, internal, conditions);
      }
      if (Array.isArray(target)) {
        const targetList = target;
        if (targetList.length === 0)
          return null;
        let lastException;
        let i = -1;
        while (++i < targetList.length) {
          const targetItem = targetList[i];
          let resolved;
          try {
            resolved = resolvePackageTarget(packageJsonUrl, targetItem, subpath, packageSubpath, base2, pattern, internal, conditions);
          } catch (error) {
            lastException = error;
            if (error.code === "ERR_INVALID_PACKAGE_TARGET")
              continue;
            throw error;
          }
          if (resolved === void 0)
            continue;
          if (resolved === null) {
            lastException = null;
            continue;
          }
          return resolved;
        }
        if (lastException === void 0 || lastException === null) {
          return lastException;
        }
        throw lastException;
      }
      if (typeof target === "object" && target !== null) {
        const keys2 = Object.getOwnPropertyNames(target);
        let i = -1;
        while (++i < keys2.length) {
          const key2 = keys2[i];
          if (isArrayIndex(key2)) {
            throw new ERR_INVALID_PACKAGE_CONFIG((0, _url().fileURLToPath)(packageJsonUrl), base2, '"exports" cannot contain numeric property keys.');
          }
        }
        i = -1;
        while (++i < keys2.length) {
          const key2 = keys2[i];
          if (key2 === "default" || conditions && conditions.has(key2)) {
            const conditionalTarget = target[key2];
            const resolved = resolvePackageTarget(packageJsonUrl, conditionalTarget, subpath, packageSubpath, base2, pattern, internal, conditions);
            if (resolved === void 0)
              continue;
            return resolved;
          }
        }
        return void 0;
      }
      if (target === null) {
        return null;
      }
      throwInvalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base2);
    }
    function isConditionalExportsMainSugar(exports2, packageJsonUrl, base2) {
      if (typeof exports2 === "string" || Array.isArray(exports2))
        return true;
      if (typeof exports2 !== "object" || exports2 === null)
        return false;
      const keys2 = Object.getOwnPropertyNames(exports2);
      let isConditionalSugar = false;
      let i = 0;
      let j = -1;
      while (++j < keys2.length) {
        const key2 = keys2[j];
        const curIsConditionalSugar = key2 === "" || key2[0] !== ".";
        if (i++ === 0) {
          isConditionalSugar = curIsConditionalSugar;
        } else if (isConditionalSugar !== curIsConditionalSugar) {
          throw new ERR_INVALID_PACKAGE_CONFIG((0, _url().fileURLToPath)(packageJsonUrl), base2, `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`);
        }
      }
      return isConditionalSugar;
    }
    function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base2, conditions) {
      let exports2 = packageConfig.exports;
      if (isConditionalExportsMainSugar(exports2, packageJsonUrl, base2))
        exports2 = {
          ".": exports2
        };
      if (own13.call(exports2, packageSubpath)) {
        const target = exports2[packageSubpath];
        const resolved = resolvePackageTarget(packageJsonUrl, target, "", packageSubpath, base2, false, false, conditions);
        if (resolved === null || resolved === void 0)
          throwExportsNotFound(packageSubpath, packageJsonUrl, base2);
        return {
          resolved,
          exact: true
        };
      }
      let bestMatch = "";
      const keys2 = Object.getOwnPropertyNames(exports2);
      let i = -1;
      while (++i < keys2.length) {
        const key2 = keys2[i];
        if (key2[key2.length - 1] === "*" && packageSubpath.startsWith(key2.slice(0, -1)) && packageSubpath.length >= key2.length && key2.length > bestMatch.length) {
          bestMatch = key2;
        } else if (key2[key2.length - 1] === "/" && packageSubpath.startsWith(key2) && key2.length > bestMatch.length) {
          bestMatch = key2;
        }
      }
      if (bestMatch) {
        const target = exports2[bestMatch];
        const pattern = bestMatch[bestMatch.length - 1] === "*";
        const subpath = packageSubpath.slice(bestMatch.length - (pattern ? 1 : 0));
        const resolved = resolvePackageTarget(packageJsonUrl, target, subpath, bestMatch, base2, pattern, false, conditions);
        if (resolved === null || resolved === void 0)
          throwExportsNotFound(packageSubpath, packageJsonUrl, base2);
        if (!pattern)
          emitFolderMapDeprecation(bestMatch, packageJsonUrl, true, base2);
        return {
          resolved,
          exact: pattern
        };
      }
      throwExportsNotFound(packageSubpath, packageJsonUrl, base2);
    }
    function packageImportsResolve(name2, base2, conditions) {
      if (name2 === "#" || name2.startsWith("#/")) {
        const reason = "is not a valid internal imports specifier name";
        throw new ERR_INVALID_MODULE_SPECIFIER(name2, reason, (0, _url().fileURLToPath)(base2));
      }
      let packageJsonUrl;
      const packageConfig = getPackageScopeConfig(base2);
      if (packageConfig.exists) {
        packageJsonUrl = (0, _url().pathToFileURL)(packageConfig.pjsonPath);
        const imports = packageConfig.imports;
        if (imports) {
          if (own13.call(imports, name2)) {
            const resolved = resolvePackageTarget(packageJsonUrl, imports[name2], "", name2, base2, false, true, conditions);
            if (resolved !== null)
              return {
                resolved,
                exact: true
              };
          } else {
            let bestMatch = "";
            const keys2 = Object.getOwnPropertyNames(imports);
            let i = -1;
            while (++i < keys2.length) {
              const key2 = keys2[i];
              if (key2[key2.length - 1] === "*" && name2.startsWith(key2.slice(0, -1)) && name2.length >= key2.length && key2.length > bestMatch.length) {
                bestMatch = key2;
              } else if (key2[key2.length - 1] === "/" && name2.startsWith(key2) && key2.length > bestMatch.length) {
                bestMatch = key2;
              }
            }
            if (bestMatch) {
              const target = imports[bestMatch];
              const pattern = bestMatch[bestMatch.length - 1] === "*";
              const subpath = name2.slice(bestMatch.length - (pattern ? 1 : 0));
              const resolved = resolvePackageTarget(packageJsonUrl, target, subpath, bestMatch, base2, pattern, true, conditions);
              if (resolved !== null) {
                if (!pattern)
                  emitFolderMapDeprecation(bestMatch, packageJsonUrl, false, base2);
                return {
                  resolved,
                  exact: pattern
                };
              }
            }
          }
        }
      }
      throwImportNotDefined(name2, packageJsonUrl, base2);
    }
    function getPackageType(url) {
      const packageConfig = getPackageScopeConfig(url);
      return packageConfig.type;
    }
    function parsePackageName(specifier, base2) {
      let separatorIndex = specifier.indexOf("/");
      let validPackageName = true;
      let isScoped = false;
      if (specifier[0] === "@") {
        isScoped = true;
        if (separatorIndex === -1 || specifier.length === 0) {
          validPackageName = false;
        } else {
          separatorIndex = specifier.indexOf("/", separatorIndex + 1);
        }
      }
      const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
      let i = -1;
      while (++i < packageName.length) {
        if (packageName[i] === "%" || packageName[i] === "\\") {
          validPackageName = false;
          break;
        }
      }
      if (!validPackageName) {
        throw new ERR_INVALID_MODULE_SPECIFIER(specifier, "is not a valid package name", (0, _url().fileURLToPath)(base2));
      }
      const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
      return {
        packageName,
        packageSubpath,
        isScoped
      };
    }
    function packageResolve(specifier, base2, conditions) {
      const {
        packageName,
        packageSubpath,
        isScoped
      } = parsePackageName(specifier, base2);
      const packageConfig = getPackageScopeConfig(base2);
      if (packageConfig.exists) {
        const packageJsonUrl2 = (0, _url().pathToFileURL)(packageConfig.pjsonPath);
        if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
          return packageExportsResolve(packageJsonUrl2, packageSubpath, packageConfig, base2, conditions).resolved;
        }
      }
      let packageJsonUrl = new (_url()).URL("./node_modules/" + packageName + "/package.json", base2);
      let packageJsonPath = (0, _url().fileURLToPath)(packageJsonUrl);
      let lastPath;
      do {
        const stat = tryStatSync(packageJsonPath.slice(0, -13));
        if (!stat.isDirectory()) {
          lastPath = packageJsonPath;
          packageJsonUrl = new (_url()).URL((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl);
          packageJsonPath = (0, _url().fileURLToPath)(packageJsonUrl);
          continue;
        }
        const packageConfig2 = getPackageConfig(packageJsonPath, specifier, base2);
        if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null)
          return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig2, base2, conditions).resolved;
        if (packageSubpath === ".")
          return legacyMainResolve(packageJsonUrl, packageConfig2, base2);
        return new (_url()).URL(packageSubpath, packageJsonUrl);
      } while (packageJsonPath.length !== lastPath.length);
      throw new ERR_MODULE_NOT_FOUND(packageName, (0, _url().fileURLToPath)(base2));
    }
    function isRelativeSpecifier(specifier) {
      if (specifier[0] === ".") {
        if (specifier.length === 1 || specifier[1] === "/")
          return true;
        if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
          return true;
        }
      }
      return false;
    }
    function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
      if (specifier === "")
        return false;
      if (specifier[0] === "/")
        return true;
      return isRelativeSpecifier(specifier);
    }
    function moduleResolve(specifier, base2, conditions) {
      let resolved;
      if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
        resolved = new (_url()).URL(specifier, base2);
      } else if (specifier[0] === "#") {
        ({
          resolved
        } = packageImportsResolve(specifier, base2, conditions));
      } else {
        try {
          resolved = new (_url()).URL(specifier);
        } catch (_unused3) {
          resolved = packageResolve(specifier, base2, conditions);
        }
      }
      return finalizeResolution(resolved, base2);
    }
    function defaultResolve(specifier, context = {}) {
      const {
        parentURL
      } = context;
      let parsed;
      try {
        parsed = new (_url()).URL(specifier);
        if (parsed.protocol === "data:") {
          return {
            url: specifier
          };
        }
      } catch (_unused4) {
      }
      if (parsed && parsed.protocol === "node:")
        return {
          url: specifier
        };
      if (parsed && parsed.protocol !== "file:" && parsed.protocol !== "data:")
        throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed);
      if (listOfBuiltins.includes(specifier)) {
        return {
          url: "node:" + specifier
        };
      }
      if (parentURL.startsWith("data:")) {
        new (_url()).URL(specifier, parentURL);
      }
      const conditions = getConditionsSet(context.conditions);
      let url = moduleResolve(specifier, new (_url()).URL(parentURL), conditions);
      const urlPath = (0, _url().fileURLToPath)(url);
      const real = (0, _fs().realpathSync)(urlPath);
      const old = url;
      url = (0, _url().pathToFileURL)(real + (urlPath.endsWith(_path().sep) ? "/" : ""));
      url.search = old.search;
      url.hash = old.hash;
      return {
        url: `${url}`
      };
    }
    function resolve(_x, _x2) {
      return _resolve.apply(this, arguments);
    }
    function _resolve() {
      _resolve = _asyncToGenerator(function* (specifier, parent) {
        if (!parent) {
          throw new Error("Please pass `parent`: `import-meta-resolve` cannot ponyfill that");
        }
        try {
          return defaultResolve(specifier, {
            parentURL: parent
          }).url;
        } catch (error) {
          return error.code === "ERR_UNSUPPORTED_DIR_IMPORT" ? error.url : Promise.reject(error);
        }
      });
      return _resolve.apply(this, arguments);
    }
  }
});

// node_modules/@babel/core/lib/config/files/import-meta-resolve.js
var require_import_meta_resolve2 = __commonJS({
  "node_modules/@babel/core/lib/config/files/import-meta-resolve.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = resolve;
    var _importMetaResolve = require_import_meta_resolve();
    function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key2, arg) {
      try {
        var info = gen[key2](arg);
        var value2 = info.value;
      } catch (error) {
        reject(error);
        return;
      }
      if (info.done) {
        resolve2(value2);
      } else {
        Promise.resolve(value2).then(_next, _throw);
      }
    }
    function _asyncToGenerator(fn) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve2, reject) {
          var gen = fn.apply(self2, args);
          function _next(value2) {
            asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value2);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
          }
          _next(void 0);
        });
      };
    }
    var import_;
    try {
      import_ = require_import();
    } catch (_unused) {
    }
    var importMetaResolveP = import_ && process.execArgv.includes("--experimental-import-meta-resolve") ? import_("data:text/javascript,export default import.meta.resolve").then((m) => m.default || _importMetaResolve.resolve, () => _importMetaResolve.resolve) : Promise.resolve(_importMetaResolve.resolve);
    function resolve(_x, _x2) {
      return _resolve.apply(this, arguments);
    }
    function _resolve() {
      _resolve = _asyncToGenerator(function* (specifier, parent) {
        return (yield importMetaResolveP)(specifier, parent);
      });
      return _resolve.apply(this, arguments);
    }
  }
});

// node_modules/@babel/core/lib/config/files/plugins.js
var require_plugins4 = __commonJS({
  "node_modules/@babel/core/lib/config/files/plugins.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.loadPlugin = loadPlugin;
    exports.loadPreset = loadPreset;
    exports.resolvePlugin = resolvePlugin;
    exports.resolvePreset = resolvePreset;
    function _debug() {
      const data3 = require_src();
      _debug = function() {
        return data3;
      };
      return data3;
    }
    function _path() {
      const data3 = require("path");
      _path = function() {
        return data3;
      };
      return data3;
    }
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _async = require_async();
    var _moduleTypes = require_module_types();
    function _url() {
      const data3 = require("url");
      _url = function() {
        return data3;
      };
      return data3;
    }
    var _importMetaResolve = require_import_meta_resolve2();
    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key2, arg) {
      try {
        var info = gen[key2](arg);
        var value2 = info.value;
      } catch (error) {
        reject(error);
        return;
      }
      if (info.done) {
        resolve(value2);
      } else {
        Promise.resolve(value2).then(_next, _throw);
      }
    }
    function _asyncToGenerator(fn) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve, reject) {
          var gen = fn.apply(self2, args);
          function _next(value2) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value2);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
          }
          _next(void 0);
        });
      };
    }
    var debug = _debug()("babel:config:loading:files:plugins");
    var EXACT_RE = /^module:/;
    var BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
    var BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
    var BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
    var BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
    var OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
    var OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
    var OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
    function* resolvePlugin(name2, dirname) {
      return yield* resolveStandardizedName("plugin", name2, dirname);
    }
    function* resolvePreset(name2, dirname) {
      return yield* resolveStandardizedName("preset", name2, dirname);
    }
    function* loadPlugin(name2, dirname) {
      const filepath = yield* resolvePlugin(name2, dirname);
      const value2 = yield* requireModule("plugin", filepath);
      debug("Loaded plugin %o from %o.", name2, dirname);
      return {
        filepath,
        value: value2
      };
    }
    function* loadPreset(name2, dirname) {
      const filepath = yield* resolvePreset(name2, dirname);
      const value2 = yield* requireModule("preset", filepath);
      debug("Loaded preset %o from %o.", name2, dirname);
      return {
        filepath,
        value: value2
      };
    }
    function standardizeName(type, name2) {
      if (_path().isAbsolute(name2))
        return name2;
      const isPreset = type === "preset";
      return name2.replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`).replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`).replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`).replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`).replace(EXACT_RE, "");
    }
    function* resolveAlternativesHelper(type, name2) {
      const standardizedName = standardizeName(type, name2);
      const {
        error,
        value: value2
      } = yield standardizedName;
      if (!error)
        return value2;
      if (error.code !== "MODULE_NOT_FOUND")
        throw error;
      if (standardizedName !== name2 && !(yield name2).error) {
        error.message += `
- If you want to resolve "${name2}", use "module:${name2}"`;
      }
      if (!(yield standardizeName(type, "@babel/" + name2)).error) {
        error.message += `
- Did you mean "@babel/${name2}"?`;
      }
      const oppositeType = type === "preset" ? "plugin" : "preset";
      if (!(yield standardizeName(oppositeType, name2)).error) {
        error.message += `
- Did you accidentally pass a ${oppositeType} as a ${type}?`;
      }
      throw error;
    }
    function tryRequireResolve(id, {
      paths: [dirname]
    }) {
      try {
        return {
          error: null,
          value: (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
            paths: [b]
          }, M = require("module")) => {
            let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
            if (f)
              return f;
            f = new Error(`Cannot resolve module '${r}'`);
            f.code = "MODULE_NOT_FOUND";
            throw f;
          })(id, {
            paths: [dirname]
          })
        };
      } catch (error) {
        return {
          error,
          value: null
        };
      }
    }
    function tryImportMetaResolve(_x, _x2) {
      return _tryImportMetaResolve.apply(this, arguments);
    }
    function _tryImportMetaResolve() {
      _tryImportMetaResolve = _asyncToGenerator(function* (id, options) {
        try {
          return {
            error: null,
            value: yield (0, _importMetaResolve.default)(id, options)
          };
        } catch (error) {
          return {
            error,
            value: null
          };
        }
      });
      return _tryImportMetaResolve.apply(this, arguments);
    }
    function resolveStandardizedNameForRequire(type, name2, dirname) {
      const it = resolveAlternativesHelper(type, name2);
      let res = it.next();
      while (!res.done) {
        res = it.next(tryRequireResolve(res.value, {
          paths: [dirname]
        }));
      }
      return res.value;
    }
    function resolveStandardizedNameForImport(_x3, _x4, _x5) {
      return _resolveStandardizedNameForImport.apply(this, arguments);
    }
    function _resolveStandardizedNameForImport() {
      _resolveStandardizedNameForImport = _asyncToGenerator(function* (type, name2, dirname) {
        const parentUrl = (0, _url().pathToFileURL)(_path().join(dirname, "./babel-virtual-resolve-base.js")).href;
        const it = resolveAlternativesHelper(type, name2);
        let res = it.next();
        while (!res.done) {
          res = it.next(yield tryImportMetaResolve(res.value, parentUrl));
        }
        return (0, _url().fileURLToPath)(res.value);
      });
      return _resolveStandardizedNameForImport.apply(this, arguments);
    }
    var resolveStandardizedName = _gensync()({
      sync(type, name2, dirname = process.cwd()) {
        return resolveStandardizedNameForRequire(type, name2, dirname);
      },
      async(type, name2, dirname = process.cwd()) {
        return _asyncToGenerator(function* () {
          if (!_moduleTypes.supportsESM) {
            return resolveStandardizedNameForRequire(type, name2, dirname);
          }
          try {
            return yield resolveStandardizedNameForImport(type, name2, dirname);
          } catch (e) {
            try {
              return resolveStandardizedNameForRequire(type, name2, dirname);
            } catch (e2) {
              if (e.type === "MODULE_NOT_FOUND")
                throw e;
              if (e2.type === "MODULE_NOT_FOUND")
                throw e2;
              throw e;
            }
          }
        })();
      }
    });
    {
      LOADING_MODULES = /* @__PURE__ */ new Set();
    }
    var LOADING_MODULES;
    function* requireModule(type, name2) {
      {
        if (!(yield* (0, _async.isAsync)()) && LOADING_MODULES.has(name2)) {
          throw new Error(`Reentrant ${type} detected trying to load "${name2}". This module is not ignored and is trying to load itself while compiling itself, leading to a dependency cycle. We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.`);
        }
      }
      try {
        {
          LOADING_MODULES.add(name2);
        }
        return yield* (0, _moduleTypes.default)(name2, `You appear to be using a native ECMAScript module ${type}, which is only supported when running Babel asynchronously.`, true);
      } catch (err) {
        err.message = `[BABEL]: ${err.message} (While processing: ${name2})`;
        throw err;
      } finally {
        {
          LOADING_MODULES.delete(name2);
        }
      }
    }
  }
});

// node_modules/@babel/core/lib/config/files/index.js
var require_files = __commonJS({
  "node_modules/@babel/core/lib/config/files/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
      enumerable: true,
      get: function() {
        return _configuration.ROOT_CONFIG_FILENAMES;
      }
    });
    Object.defineProperty(exports, "findConfigUpwards", {
      enumerable: true,
      get: function() {
        return _configuration.findConfigUpwards;
      }
    });
    Object.defineProperty(exports, "findPackageData", {
      enumerable: true,
      get: function() {
        return _package.findPackageData;
      }
    });
    Object.defineProperty(exports, "findRelativeConfig", {
      enumerable: true,
      get: function() {
        return _configuration.findRelativeConfig;
      }
    });
    Object.defineProperty(exports, "findRootConfig", {
      enumerable: true,
      get: function() {
        return _configuration.findRootConfig;
      }
    });
    Object.defineProperty(exports, "loadConfig", {
      enumerable: true,
      get: function() {
        return _configuration.loadConfig;
      }
    });
    Object.defineProperty(exports, "loadPlugin", {
      enumerable: true,
      get: function() {
        return plugins.loadPlugin;
      }
    });
    Object.defineProperty(exports, "loadPreset", {
      enumerable: true,
      get: function() {
        return plugins.loadPreset;
      }
    });
    exports.resolvePreset = exports.resolvePlugin = void 0;
    Object.defineProperty(exports, "resolveShowConfigPath", {
      enumerable: true,
      get: function() {
        return _configuration.resolveShowConfigPath;
      }
    });
    var _package = require_package();
    var _configuration = require_configuration();
    var plugins = require_plugins4();
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var resolvePlugin = _gensync()(plugins.resolvePlugin).sync;
    exports.resolvePlugin = resolvePlugin;
    var resolvePreset = _gensync()(plugins.resolvePreset).sync;
    exports.resolvePreset = resolvePreset;
  }
});

// node_modules/@babel/core/lib/transform.js
var require_transform = __commonJS({
  "node_modules/@babel/core/lib/transform.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.transform = void 0;
    exports.transformAsync = transformAsync2;
    exports.transformSync = transformSync2;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _config = require_config();
    var _transformation = require_transformation();
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var transformRunner = _gensync()(function* transform2(code2, opts) {
      const config = yield* (0, _config.default)(opts);
      if (config === null)
        return null;
      return yield* (0, _transformation.run)(config, code2);
    });
    var transform = function transform2(code2, optsOrCallback, maybeCallback) {
      let opts;
      let callback;
      if (typeof optsOrCallback === "function") {
        callback = optsOrCallback;
        opts = void 0;
      } else {
        opts = optsOrCallback;
        callback = maybeCallback;
      }
      if (callback === void 0) {
        {
          return (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.sync)(code2, opts);
        }
      }
      (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.errback)(code2, opts, callback);
    };
    exports.transform = transform;
    function transformSync2(...args) {
      return (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.sync)(...args);
    }
    function transformAsync2(...args) {
      return (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.async)(...args);
    }
  }
});

// node_modules/@babel/core/lib/transform-ast.js
var require_transform_ast = __commonJS({
  "node_modules/@babel/core/lib/transform-ast.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.transformFromAst = void 0;
    exports.transformFromAstAsync = transformFromAstAsync;
    exports.transformFromAstSync = transformFromAstSync;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _config = require_config();
    var _transformation = require_transformation();
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var transformFromAstRunner = _gensync()(function* (ast, code2, opts) {
      const config = yield* (0, _config.default)(opts);
      if (config === null)
        return null;
      if (!ast)
        throw new Error("No AST given");
      return yield* (0, _transformation.run)(config, code2, ast);
    });
    var transformFromAst = function transformFromAst2(ast, code2, optsOrCallback, maybeCallback) {
      let opts;
      let callback;
      if (typeof optsOrCallback === "function") {
        callback = optsOrCallback;
        opts = void 0;
      } else {
        opts = optsOrCallback;
        callback = maybeCallback;
      }
      if (callback === void 0) {
        {
          return (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.sync)(ast, code2, opts);
        }
      }
      (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.errback)(ast, code2, opts, callback);
    };
    exports.transformFromAst = transformFromAst;
    function transformFromAstSync(...args) {
      return (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.sync)(...args);
    }
    function transformFromAstAsync(...args) {
      return (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.async)(...args);
    }
  }
});

// node_modules/@babel/core/lib/parse.js
var require_parse3 = __commonJS({
  "node_modules/@babel/core/lib/parse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.parse = void 0;
    exports.parseAsync = parseAsync;
    exports.parseSync = parseSync;
    function _gensync() {
      const data3 = require_gensync();
      _gensync = function() {
        return data3;
      };
      return data3;
    }
    var _config = require_config();
    var _parser = require_parser();
    var _normalizeOpts = require_normalize_opts();
    var _rewriteStackTrace = require_rewrite_stack_trace();
    var parseRunner = _gensync()(function* parse10(code2, opts) {
      const config = yield* (0, _config.default)(opts);
      if (config === null) {
        return null;
      }
      return yield* (0, _parser.default)(config.passes, (0, _normalizeOpts.default)(config), code2);
    });
    var parse9 = function parse10(code2, opts, callback) {
      if (typeof opts === "function") {
        callback = opts;
        opts = void 0;
      }
      if (callback === void 0) {
        {
          return (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.sync)(code2, opts);
        }
      }
      (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.errback)(code2, opts, callback);
    };
    exports.parse = parse9;
    function parseSync(...args) {
      return (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.sync)(...args);
    }
    function parseAsync(...args) {
      return (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.async)(...args);
    }
  }
});

// node_modules/@babel/core/lib/index.js
var require_lib32 = __commonJS({
  "node_modules/@babel/core/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.DEFAULT_EXTENSIONS = void 0;
    Object.defineProperty(exports, "File", {
      enumerable: true,
      get: function() {
        return _file.default;
      }
    });
    exports.OptionManager = void 0;
    exports.Plugin = Plugin;
    Object.defineProperty(exports, "buildExternalHelpers", {
      enumerable: true,
      get: function() {
        return _buildExternalHelpers.default;
      }
    });
    Object.defineProperty(exports, "createConfigItem", {
      enumerable: true,
      get: function() {
        return _config.createConfigItem;
      }
    });
    Object.defineProperty(exports, "createConfigItemAsync", {
      enumerable: true,
      get: function() {
        return _config.createConfigItemAsync;
      }
    });
    Object.defineProperty(exports, "createConfigItemSync", {
      enumerable: true,
      get: function() {
        return _config.createConfigItemSync;
      }
    });
    Object.defineProperty(exports, "getEnv", {
      enumerable: true,
      get: function() {
        return _environment.getEnv;
      }
    });
    Object.defineProperty(exports, "loadOptions", {
      enumerable: true,
      get: function() {
        return _config.loadOptions;
      }
    });
    Object.defineProperty(exports, "loadOptionsAsync", {
      enumerable: true,
      get: function() {
        return _config.loadOptionsAsync;
      }
    });
    Object.defineProperty(exports, "loadOptionsSync", {
      enumerable: true,
      get: function() {
        return _config.loadOptionsSync;
      }
    });
    Object.defineProperty(exports, "loadPartialConfig", {
      enumerable: true,
      get: function() {
        return _config.loadPartialConfig;
      }
    });
    Object.defineProperty(exports, "loadPartialConfigAsync", {
      enumerable: true,
      get: function() {
        return _config.loadPartialConfigAsync;
      }
    });
    Object.defineProperty(exports, "loadPartialConfigSync", {
      enumerable: true,
      get: function() {
        return _config.loadPartialConfigSync;
      }
    });
    Object.defineProperty(exports, "parse", {
      enumerable: true,
      get: function() {
        return _parse.parse;
      }
    });
    Object.defineProperty(exports, "parseAsync", {
      enumerable: true,
      get: function() {
        return _parse.parseAsync;
      }
    });
    Object.defineProperty(exports, "parseSync", {
      enumerable: true,
      get: function() {
        return _parse.parseSync;
      }
    });
    Object.defineProperty(exports, "resolvePlugin", {
      enumerable: true,
      get: function() {
        return _files.resolvePlugin;
      }
    });
    Object.defineProperty(exports, "resolvePreset", {
      enumerable: true,
      get: function() {
        return _files.resolvePreset;
      }
    });
    Object.defineProperty((0, exports), "template", {
      enumerable: true,
      get: function() {
        return _template().default;
      }
    });
    Object.defineProperty((0, exports), "tokTypes", {
      enumerable: true,
      get: function() {
        return _parser().tokTypes;
      }
    });
    Object.defineProperty(exports, "transform", {
      enumerable: true,
      get: function() {
        return _transform.transform;
      }
    });
    Object.defineProperty(exports, "transformAsync", {
      enumerable: true,
      get: function() {
        return _transform.transformAsync;
      }
    });
    Object.defineProperty(exports, "transformFile", {
      enumerable: true,
      get: function() {
        return _transformFile.transformFile;
      }
    });
    Object.defineProperty(exports, "transformFileAsync", {
      enumerable: true,
      get: function() {
        return _transformFile.transformFileAsync;
      }
    });
    Object.defineProperty(exports, "transformFileSync", {
      enumerable: true,
      get: function() {
        return _transformFile.transformFileSync;
      }
    });
    Object.defineProperty(exports, "transformFromAst", {
      enumerable: true,
      get: function() {
        return _transformAst.transformFromAst;
      }
    });
    Object.defineProperty(exports, "transformFromAstAsync", {
      enumerable: true,
      get: function() {
        return _transformAst.transformFromAstAsync;
      }
    });
    Object.defineProperty(exports, "transformFromAstSync", {
      enumerable: true,
      get: function() {
        return _transformAst.transformFromAstSync;
      }
    });
    Object.defineProperty(exports, "transformSync", {
      enumerable: true,
      get: function() {
        return _transform.transformSync;
      }
    });
    Object.defineProperty((0, exports), "traverse", {
      enumerable: true,
      get: function() {
        return _traverse().default;
      }
    });
    exports.version = exports.types = void 0;
    var _file = require_file();
    var _buildExternalHelpers = require_build_external_helpers();
    var _files = require_files();
    var _environment = require_environment();
    function _types() {
      const data3 = require_lib3();
      _types = function() {
        return data3;
      };
      return data3;
    }
    Object.defineProperty((0, exports), "types", {
      enumerable: true,
      get: function() {
        return _types();
      }
    });
    function _parser() {
      const data3 = require_lib9();
      _parser = function() {
        return data3;
      };
      return data3;
    }
    function _traverse() {
      const data3 = require_lib13();
      _traverse = function() {
        return data3;
      };
      return data3;
    }
    function _template() {
      const data3 = require_lib11();
      _template = function() {
        return data3;
      };
      return data3;
    }
    var _config = require_config();
    var _transform = require_transform();
    var _transformFile = require_transform_file();
    var _transformAst = require_transform_ast();
    var _parse = require_parse3();
    var thisFile = require_lib32();
    var version3 = "7.21.4";
    exports.version = version3;
    var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"]);
    exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
    var OptionManager = class {
      init(opts) {
        return (0, _config.loadOptionsSync)(opts);
      }
    };
    exports.OptionManager = OptionManager;
    function Plugin(alias) {
      throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`);
    }
  }
});

// node_modules/@babel/plugin-transform-react-jsx/lib/create-plugin.js
var require_create_plugin = __commonJS({
  "node_modules/@babel/plugin-transform-react-jsx/lib/create-plugin.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = createPlugin;
    var _pluginSyntaxJsx = require_lib29();
    var _helperPluginUtils = require_lib20();
    var _core = require_lib32();
    var _helperModuleImports = require_lib15();
    var _helperAnnotateAsPure = require_lib25();
    var DEFAULT = {
      importSource: "react",
      runtime: "automatic",
      pragma: "React.createElement",
      pragmaFrag: "React.Fragment"
    };
    var JSX_SOURCE_ANNOTATION_REGEX = /^\s*\*?\s*@jsxImportSource\s+([^\s]+)\s*$/m;
    var JSX_RUNTIME_ANNOTATION_REGEX = /^\s*\*?\s*@jsxRuntime\s+([^\s]+)\s*$/m;
    var JSX_ANNOTATION_REGEX = /^\s*\*?\s*@jsx\s+([^\s]+)\s*$/m;
    var JSX_FRAG_ANNOTATION_REGEX = /^\s*\*?\s*@jsxFrag\s+([^\s]+)\s*$/m;
    var get = (pass, name2) => pass.get(`@babel/plugin-react-jsx/${name2}`);
    var set = (pass, name2, v) => pass.set(`@babel/plugin-react-jsx/${name2}`, v);
    function hasProto(node2) {
      return node2.properties.some((value2) => _core.types.isObjectProperty(value2, {
        computed: false,
        shorthand: false
      }) && (_core.types.isIdentifier(value2.key, {
        name: "__proto__"
      }) || _core.types.isStringLiteral(value2.key, {
        value: "__proto__"
      })));
    }
    function createPlugin({
      name: name2,
      development: development2
    }) {
      return (0, _helperPluginUtils.declare)((_, options) => {
        const {
          pure: PURE_ANNOTATION,
          throwIfNamespace = true,
          filter,
          runtime: RUNTIME_DEFAULT = development2 ? "automatic" : "classic",
          importSource: IMPORT_SOURCE_DEFAULT = DEFAULT.importSource,
          pragma: PRAGMA_DEFAULT = DEFAULT.pragma,
          pragmaFrag: PRAGMA_FRAG_DEFAULT = DEFAULT.pragmaFrag
        } = options;
        {
          var {
            useSpread = false,
            useBuiltIns = false
          } = options;
          if (RUNTIME_DEFAULT === "classic") {
            if (typeof useSpread !== "boolean") {
              throw new Error("transform-react-jsx currently only accepts a boolean option for useSpread (defaults to false)");
            }
            if (typeof useBuiltIns !== "boolean") {
              throw new Error("transform-react-jsx currently only accepts a boolean option for useBuiltIns (defaults to false)");
            }
            if (useSpread && useBuiltIns) {
              throw new Error("transform-react-jsx currently only accepts useBuiltIns or useSpread but not both");
            }
          }
        }
        const injectMetaPropertiesVisitor = {
          JSXOpeningElement(path, state) {
            const attributes = [];
            if (isThisAllowed(path.scope)) {
              attributes.push(_core.types.jsxAttribute(_core.types.jsxIdentifier("__self"), _core.types.jsxExpressionContainer(_core.types.thisExpression())));
            }
            attributes.push(_core.types.jsxAttribute(_core.types.jsxIdentifier("__source"), _core.types.jsxExpressionContainer(makeSource(path, state))));
            path.pushContainer("attributes", attributes);
          }
        };
        return {
          name: name2,
          inherits: _pluginSyntaxJsx.default,
          visitor: {
            JSXNamespacedName(path) {
              if (throwIfNamespace) {
                throw path.buildCodeFrameError(`Namespace tags are not supported by default. React's JSX doesn't support namespace tags. You can set \`throwIfNamespace: false\` to bypass this warning.`);
              }
            },
            JSXSpreadChild(path) {
              throw path.buildCodeFrameError("Spread children are not supported in React.");
            },
            Program: {
              enter(path, state) {
                const {
                  file
                } = state;
                let runtime = RUNTIME_DEFAULT;
                let source2 = IMPORT_SOURCE_DEFAULT;
                let pragma = PRAGMA_DEFAULT;
                let pragmaFrag = PRAGMA_FRAG_DEFAULT;
                let sourceSet = !!options.importSource;
                let pragmaSet = !!options.pragma;
                let pragmaFragSet = !!options.pragmaFrag;
                if (file.ast.comments) {
                  for (const comment2 of file.ast.comments) {
                    const sourceMatches = JSX_SOURCE_ANNOTATION_REGEX.exec(comment2.value);
                    if (sourceMatches) {
                      source2 = sourceMatches[1];
                      sourceSet = true;
                    }
                    const runtimeMatches = JSX_RUNTIME_ANNOTATION_REGEX.exec(comment2.value);
                    if (runtimeMatches) {
                      runtime = runtimeMatches[1];
                    }
                    const jsxMatches = JSX_ANNOTATION_REGEX.exec(comment2.value);
                    if (jsxMatches) {
                      pragma = jsxMatches[1];
                      pragmaSet = true;
                    }
                    const jsxFragMatches = JSX_FRAG_ANNOTATION_REGEX.exec(comment2.value);
                    if (jsxFragMatches) {
                      pragmaFrag = jsxFragMatches[1];
                      pragmaFragSet = true;
                    }
                  }
                }
                set(state, "runtime", runtime);
                if (runtime === "classic") {
                  if (sourceSet) {
                    throw path.buildCodeFrameError(`importSource cannot be set when runtime is classic.`);
                  }
                  const createElement = toMemberExpression2(pragma);
                  const fragment = toMemberExpression2(pragmaFrag);
                  set(state, "id/createElement", () => _core.types.cloneNode(createElement));
                  set(state, "id/fragment", () => _core.types.cloneNode(fragment));
                  set(state, "defaultPure", pragma === DEFAULT.pragma);
                } else if (runtime === "automatic") {
                  if (pragmaSet || pragmaFragSet) {
                    throw path.buildCodeFrameError(`pragma and pragmaFrag cannot be set when runtime is automatic.`);
                  }
                  const define2 = (name3, id) => set(state, name3, createImportLazily(state, path, id, source2));
                  define2("id/jsx", development2 ? "jsxDEV" : "jsx");
                  define2("id/jsxs", development2 ? "jsxDEV" : "jsxs");
                  define2("id/createElement", "createElement");
                  define2("id/fragment", "Fragment");
                  set(state, "defaultPure", source2 === DEFAULT.importSource);
                } else {
                  throw path.buildCodeFrameError(`Runtime must be either "classic" or "automatic".`);
                }
                if (development2) {
                  path.traverse(injectMetaPropertiesVisitor, state);
                }
              }
            },
            JSXFragment: {
              exit(path, file) {
                let callExpr;
                if (get(file, "runtime") === "classic") {
                  callExpr = buildCreateElementFragmentCall(path, file);
                } else {
                  callExpr = buildJSXFragmentCall(path, file);
                }
                path.replaceWith(_core.types.inherits(callExpr, path.node));
              }
            },
            JSXElement: {
              exit(path, file) {
                let callExpr;
                if (get(file, "runtime") === "classic" || shouldUseCreateElement(path)) {
                  callExpr = buildCreateElementCall(path, file);
                } else {
                  callExpr = buildJSXElementCall(path, file);
                }
                path.replaceWith(_core.types.inherits(callExpr, path.node));
              }
            },
            JSXAttribute(path) {
              if (_core.types.isJSXElement(path.node.value)) {
                path.node.value = _core.types.jsxExpressionContainer(path.node.value);
              }
            }
          }
        };
        function isDerivedClass(classPath) {
          return classPath.node.superClass !== null;
        }
        function isThisAllowed(scope) {
          do {
            const {
              path
            } = scope;
            if (path.isFunctionParent() && !path.isArrowFunctionExpression()) {
              if (!path.isMethod()) {
                return true;
              }
              if (path.node.kind !== "constructor") {
                return true;
              }
              return !isDerivedClass(path.parentPath.parentPath);
            }
            if (path.isTSModuleBlock()) {
              return false;
            }
          } while (scope = scope.parent);
          return true;
        }
        function call(pass, name3, args) {
          const node2 = _core.types.callExpression(get(pass, `id/${name3}`)(), args);
          if (PURE_ANNOTATION != null ? PURE_ANNOTATION : get(pass, "defaultPure"))
            (0, _helperAnnotateAsPure.default)(node2);
          return node2;
        }
        function shouldUseCreateElement(path) {
          const openingPath = path.get("openingElement");
          const attributes = openingPath.node.attributes;
          let seenPropsSpread = false;
          for (let i = 0; i < attributes.length; i++) {
            const attr = attributes[i];
            if (seenPropsSpread && _core.types.isJSXAttribute(attr) && attr.name.name === "key") {
              return true;
            } else if (_core.types.isJSXSpreadAttribute(attr)) {
              seenPropsSpread = true;
            }
          }
          return false;
        }
        function convertJSXIdentifier(node2, parent) {
          if (_core.types.isJSXIdentifier(node2)) {
            if (node2.name === "this" && _core.types.isReferenced(node2, parent)) {
              return _core.types.thisExpression();
            } else if (_core.types.isValidIdentifier(node2.name, false)) {
              node2.type = "Identifier";
              return node2;
            } else {
              return _core.types.stringLiteral(node2.name);
            }
          } else if (_core.types.isJSXMemberExpression(node2)) {
            return _core.types.memberExpression(convertJSXIdentifier(node2.object, node2), convertJSXIdentifier(node2.property, node2));
          } else if (_core.types.isJSXNamespacedName(node2)) {
            return _core.types.stringLiteral(`${node2.namespace.name}:${node2.name.name}`);
          }
          return node2;
        }
        function convertAttributeValue(node2) {
          if (_core.types.isJSXExpressionContainer(node2)) {
            return node2.expression;
          } else {
            return node2;
          }
        }
        function accumulateAttribute(array, attribute) {
          if (_core.types.isJSXSpreadAttribute(attribute.node)) {
            const arg = attribute.node.argument;
            if (_core.types.isObjectExpression(arg) && !hasProto(arg)) {
              array.push(...arg.properties);
            } else {
              array.push(_core.types.spreadElement(arg));
            }
            return array;
          }
          const value2 = convertAttributeValue(attribute.node.name.name !== "key" ? attribute.node.value || _core.types.booleanLiteral(true) : attribute.node.value);
          if (attribute.node.name.name === "key" && value2 === null) {
            throw attribute.buildCodeFrameError('Please provide an explicit key value. Using "key" as a shorthand for "key={true}" is not allowed.');
          }
          if (_core.types.isStringLiteral(value2) && !_core.types.isJSXExpressionContainer(attribute.node.value)) {
            var _value$extra;
            value2.value = value2.value.replace(/\n\s+/g, " ");
            (_value$extra = value2.extra) == null ? true : delete _value$extra.raw;
          }
          if (_core.types.isJSXNamespacedName(attribute.node.name)) {
            attribute.node.name = _core.types.stringLiteral(attribute.node.name.namespace.name + ":" + attribute.node.name.name.name);
          } else if (_core.types.isValidIdentifier(attribute.node.name.name, false)) {
            attribute.node.name.type = "Identifier";
          } else {
            attribute.node.name = _core.types.stringLiteral(attribute.node.name.name);
          }
          array.push(_core.types.inherits(_core.types.objectProperty(attribute.node.name, value2), attribute.node));
          return array;
        }
        function buildChildrenProperty(children) {
          let childrenNode;
          if (children.length === 1) {
            childrenNode = children[0];
          } else if (children.length > 1) {
            childrenNode = _core.types.arrayExpression(children);
          } else {
            return void 0;
          }
          return _core.types.objectProperty(_core.types.identifier("children"), childrenNode);
        }
        function buildJSXElementCall(path, file) {
          const openingPath = path.get("openingElement");
          const args = [getTag(openingPath)];
          const attribsArray = [];
          const extracted = /* @__PURE__ */ Object.create(null);
          for (const attr of openingPath.get("attributes")) {
            if (attr.isJSXAttribute() && _core.types.isJSXIdentifier(attr.node.name)) {
              const {
                name: name3
              } = attr.node.name;
              switch (name3) {
                case "__source":
                case "__self":
                  if (extracted[name3])
                    throw sourceSelfError(path, name3);
                case "key": {
                  const keyValue = convertAttributeValue(attr.node.value);
                  if (keyValue === null) {
                    throw attr.buildCodeFrameError('Please provide an explicit key value. Using "key" as a shorthand for "key={true}" is not allowed.');
                  }
                  extracted[name3] = keyValue;
                  break;
                }
                default:
                  attribsArray.push(attr);
              }
            } else {
              attribsArray.push(attr);
            }
          }
          const children = _core.types.react.buildChildren(path.node);
          let attribs;
          if (attribsArray.length || children.length) {
            attribs = buildJSXOpeningElementAttributes(attribsArray, children);
          } else {
            attribs = _core.types.objectExpression([]);
          }
          args.push(attribs);
          if (development2) {
            var _extracted$key;
            args.push((_extracted$key = extracted.key) != null ? _extracted$key : path.scope.buildUndefinedNode(), _core.types.booleanLiteral(children.length > 1));
            if (extracted.__source) {
              args.push(extracted.__source);
              if (extracted.__self)
                args.push(extracted.__self);
            } else if (extracted.__self) {
              args.push(path.scope.buildUndefinedNode(), extracted.__self);
            }
          } else if (extracted.key !== void 0) {
            args.push(extracted.key);
          }
          return call(file, children.length > 1 ? "jsxs" : "jsx", args);
        }
        function buildJSXOpeningElementAttributes(attribs, children) {
          const props = attribs.reduce(accumulateAttribute, []);
          if ((children == null ? void 0 : children.length) > 0) {
            props.push(buildChildrenProperty(children));
          }
          return _core.types.objectExpression(props);
        }
        function buildJSXFragmentCall(path, file) {
          const args = [get(file, "id/fragment")()];
          const children = _core.types.react.buildChildren(path.node);
          args.push(_core.types.objectExpression(children.length > 0 ? [buildChildrenProperty(children)] : []));
          if (development2) {
            args.push(path.scope.buildUndefinedNode(), _core.types.booleanLiteral(children.length > 1));
          }
          return call(file, children.length > 1 ? "jsxs" : "jsx", args);
        }
        function buildCreateElementFragmentCall(path, file) {
          if (filter && !filter(path.node, file))
            return;
          return call(file, "createElement", [get(file, "id/fragment")(), _core.types.nullLiteral(), ..._core.types.react.buildChildren(path.node)]);
        }
        function buildCreateElementCall(path, file) {
          const openingPath = path.get("openingElement");
          return call(file, "createElement", [getTag(openingPath), buildCreateElementOpeningElementAttributes(file, path, openingPath.get("attributes")), ..._core.types.react.buildChildren(path.node)]);
        }
        function getTag(openingPath) {
          const tagExpr = convertJSXIdentifier(openingPath.node.name, openingPath.node);
          let tagName;
          if (_core.types.isIdentifier(tagExpr)) {
            tagName = tagExpr.name;
          } else if (_core.types.isStringLiteral(tagExpr)) {
            tagName = tagExpr.value;
          }
          if (_core.types.react.isCompatTag(tagName)) {
            return _core.types.stringLiteral(tagName);
          } else {
            return tagExpr;
          }
        }
        function buildCreateElementOpeningElementAttributes(file, path, attribs) {
          const runtime = get(file, "runtime");
          {
            if (runtime !== "automatic") {
              const objs = [];
              const props2 = attribs.reduce(accumulateAttribute, []);
              if (!useSpread) {
                let start3 = 0;
                props2.forEach((prop, i) => {
                  if (_core.types.isSpreadElement(prop)) {
                    if (i > start3) {
                      objs.push(_core.types.objectExpression(props2.slice(start3, i)));
                    }
                    objs.push(prop.argument);
                    start3 = i + 1;
                  }
                });
                if (props2.length > start3) {
                  objs.push(_core.types.objectExpression(props2.slice(start3)));
                }
              } else if (props2.length) {
                objs.push(_core.types.objectExpression(props2));
              }
              if (!objs.length) {
                return _core.types.nullLiteral();
              }
              if (objs.length === 1) {
                if (!(_core.types.isSpreadElement(props2[0]) && _core.types.isObjectExpression(props2[0].argument))) {
                  return objs[0];
                }
              }
              if (!_core.types.isObjectExpression(objs[0])) {
                objs.unshift(_core.types.objectExpression([]));
              }
              const helper = useBuiltIns ? _core.types.memberExpression(_core.types.identifier("Object"), _core.types.identifier("assign")) : file.addHelper("extends");
              return _core.types.callExpression(helper, objs);
            }
          }
          const props = [];
          const found = /* @__PURE__ */ Object.create(null);
          for (const attr of attribs) {
            const name3 = _core.types.isJSXAttribute(attr) && _core.types.isJSXIdentifier(attr.name) && attr.name.name;
            if (runtime === "automatic" && (name3 === "__source" || name3 === "__self")) {
              if (found[name3])
                throw sourceSelfError(path, name3);
              found[name3] = true;
            }
            accumulateAttribute(props, attr);
          }
          return props.length === 1 && _core.types.isSpreadElement(props[0]) && !_core.types.isObjectExpression(props[0].argument) ? props[0].argument : props.length > 0 ? _core.types.objectExpression(props) : _core.types.nullLiteral();
        }
      });
      function getSource(source2, importName) {
        switch (importName) {
          case "Fragment":
            return `${source2}/${development2 ? "jsx-dev-runtime" : "jsx-runtime"}`;
          case "jsxDEV":
            return `${source2}/jsx-dev-runtime`;
          case "jsx":
          case "jsxs":
            return `${source2}/jsx-runtime`;
          case "createElement":
            return source2;
        }
      }
      function createImportLazily(pass, path, importName, source2) {
        return () => {
          const actualSource = getSource(source2, importName);
          if ((0, _helperModuleImports.isModule)(path)) {
            let reference = get(pass, `imports/${importName}`);
            if (reference)
              return _core.types.cloneNode(reference);
            reference = (0, _helperModuleImports.addNamed)(path, importName, actualSource, {
              importedInterop: "uncompiled",
              importPosition: "after"
            });
            set(pass, `imports/${importName}`, reference);
            return reference;
          } else {
            let reference = get(pass, `requires/${actualSource}`);
            if (reference) {
              reference = _core.types.cloneNode(reference);
            } else {
              reference = (0, _helperModuleImports.addNamespace)(path, actualSource, {
                importedInterop: "uncompiled"
              });
              set(pass, `requires/${actualSource}`, reference);
            }
            return _core.types.memberExpression(reference, _core.types.identifier(importName));
          }
        };
      }
    }
    function toMemberExpression2(id) {
      return id.split(".").map((name2) => _core.types.identifier(name2)).reduce((object, property) => _core.types.memberExpression(object, property));
    }
    function makeSource(path, state) {
      const location2 = path.node.loc;
      if (!location2) {
        return path.scope.buildUndefinedNode();
      }
      if (!state.fileNameIdentifier) {
        const {
          filename = ""
        } = state;
        const fileNameIdentifier = path.scope.generateUidIdentifier("_jsxFileName");
        path.scope.getProgramParent().push({
          id: fileNameIdentifier,
          init: _core.types.stringLiteral(filename)
        });
        state.fileNameIdentifier = fileNameIdentifier;
      }
      return makeTrace(_core.types.cloneNode(state.fileNameIdentifier), location2.start.line, location2.start.column);
    }
    function makeTrace(fileNameIdentifier, lineNumber, column0Based) {
      const fileLineLiteral = lineNumber != null ? _core.types.numericLiteral(lineNumber) : _core.types.nullLiteral();
      const fileColumnLiteral = column0Based != null ? _core.types.numericLiteral(column0Based + 1) : _core.types.nullLiteral();
      return _core.template.expression.ast`{
    fileName: ${fileNameIdentifier},
    lineNumber: ${fileLineLiteral},
    columnNumber: ${fileColumnLiteral},
  }`;
    }
    function sourceSelfError(path, name2) {
      const pluginName = `transform-react-jsx-${name2.slice(2)}`;
      return path.buildCodeFrameError(`Duplicate ${name2} prop found. You are most likely using the deprecated ${pluginName} Babel plugin. Both __source and __self are automatically set when using the automatic runtime. Please remove transform-react-jsx-source and transform-react-jsx-self from your Babel config.`);
    }
  }
});

// node_modules/@babel/plugin-transform-react-jsx/lib/index.js
var require_lib33 = __commonJS({
  "node_modules/@babel/plugin-transform-react-jsx/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _createPlugin = require_create_plugin();
    var _default = (0, _createPlugin.default)({
      name: "transform-react-jsx",
      development: false
    });
    exports.default = _default;
  }
});

// node_modules/@babel/plugin-transform-react-jsx/lib/development.js
var require_development = __commonJS({
  "node_modules/@babel/plugin-transform-react-jsx/lib/development.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _createPlugin = require_create_plugin();
    var _default = (0, _createPlugin.default)({
      name: "transform-react-jsx/development",
      development: true
    });
    exports.default = _default;
  }
});

// node_modules/@babel/plugin-transform-react-jsx-development/lib/index.js
var require_lib34 = __commonJS({
  "node_modules/@babel/plugin-transform-react-jsx-development/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    Object.defineProperty(exports, "default", {
      enumerable: true,
      get: function() {
        return _development.default;
      }
    });
    var _development = require_development();
  }
});

// node_modules/@babel/plugin-transform-react-display-name/lib/index.js
var require_lib35 = __commonJS({
  "node_modules/@babel/plugin-transform-react-display-name/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperPluginUtils = require_lib20();
    var _path = require("path");
    var _core = require_lib32();
    var _default = (0, _helperPluginUtils.declare)((api) => {
      api.assertVersion(7);
      function addDisplayName(id, call) {
        const props = call.arguments[0].properties;
        let safe = true;
        for (let i = 0; i < props.length; i++) {
          const prop = props[i];
          if (_core.types.isSpreadElement(prop)) {
            continue;
          }
          const key2 = _core.types.toComputedKey(prop);
          if (_core.types.isStringLiteral(key2, {
            value: "displayName"
          })) {
            safe = false;
            break;
          }
        }
        if (safe) {
          props.unshift(_core.types.objectProperty(_core.types.identifier("displayName"), _core.types.stringLiteral(id)));
        }
      }
      const isCreateClassCallExpression = _core.types.buildMatchMemberExpression("React.createClass");
      const isCreateClassAddon = (callee) => _core.types.isIdentifier(callee, {
        name: "createReactClass"
      });
      function isCreateClass(node2) {
        if (!node2 || !_core.types.isCallExpression(node2))
          return false;
        if (!isCreateClassCallExpression(node2.callee) && !isCreateClassAddon(node2.callee)) {
          return false;
        }
        const args = node2.arguments;
        if (args.length !== 1)
          return false;
        const first = args[0];
        if (!_core.types.isObjectExpression(first))
          return false;
        return true;
      }
      return {
        name: "transform-react-display-name",
        visitor: {
          ExportDefaultDeclaration({
            node: node2
          }, state) {
            if (isCreateClass(node2.declaration)) {
              const filename = state.filename || "unknown";
              let displayName = _path.basename(filename, _path.extname(filename));
              if (displayName === "index") {
                displayName = _path.basename(_path.dirname(filename));
              }
              addDisplayName(displayName, node2.declaration);
            }
          },
          CallExpression(path) {
            const {
              node: node2
            } = path;
            if (!isCreateClass(node2))
              return;
            let id;
            path.find(function(path2) {
              if (path2.isAssignmentExpression()) {
                id = path2.node.left;
              } else if (path2.isObjectProperty()) {
                id = path2.node.key;
              } else if (path2.isVariableDeclarator()) {
                id = path2.node.id;
              } else if (path2.isStatement()) {
                return true;
              }
              if (id)
                return true;
            });
            if (!id)
              return;
            if (_core.types.isMemberExpression(id)) {
              id = id.property;
            }
            if (_core.types.isIdentifier(id)) {
              addDisplayName(id.name, node2);
            }
          }
        }
      };
    });
    exports.default = _default;
  }
});

// node_modules/@babel/plugin-transform-react-pure-annotations/lib/index.js
var require_lib36 = __commonJS({
  "node_modules/@babel/plugin-transform-react-pure-annotations/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;
    var _helperPluginUtils = require_lib20();
    var _helperAnnotateAsPure = require_lib25();
    var _core = require_lib32();
    var PURE_CALLS = [["react", /* @__PURE__ */ new Set(["cloneElement", "createContext", "createElement", "createFactory", "createRef", "forwardRef", "isValidElement", "memo", "lazy"])], ["react-dom", /* @__PURE__ */ new Set(["createPortal"])]];
    var _default = (0, _helperPluginUtils.declare)((api) => {
      api.assertVersion(7);
      return {
        name: "transform-react-pure-annotations",
        visitor: {
          CallExpression(path) {
            if (isReactCall(path)) {
              (0, _helperAnnotateAsPure.default)(path);
            }
          }
        }
      };
    });
    exports.default = _default;
    function isReactCall(path) {
      const calleePath = path.get("callee");
      if (!calleePath.isMemberExpression()) {
        for (const [module3, methods] of PURE_CALLS) {
          for (const method of methods) {
            if (calleePath.referencesImport(module3, method)) {
              return true;
            }
          }
        }
        return false;
      }
      const object = calleePath.get("object");
      const callee = calleePath.node;
      if (!callee.computed && _core.types.isIdentifier(callee.property)) {
        const propertyName = callee.property.name;
        for (const [module3, methods] of PURE_CALLS) {
          if (object.referencesImport(module3, "default") || object.referencesImport(module3, "*")) {
            return methods.has(propertyName);
          }
        }
      }
      return false;
    }
  }
});

// node_modules/@babel/preset-react/lib/index.js
var require_lib37 = __commonJS({
  "node_modules/@babel/preset-react/lib/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var helperPluginUtils = require_lib20();
    var transformReactJSX = require_lib33();
    var transformReactJSXDevelopment = require_lib34();
    var transformReactDisplayName = require_lib35();
    var transformReactPure = require_lib36();
    var helperValidatorOption = require_lib18();
    function _interopDefaultLegacy(e) {
      return e && typeof e === "object" && "default" in e ? e : { "default": e };
    }
    var transformReactJSX__default = /* @__PURE__ */ _interopDefaultLegacy(transformReactJSX);
    var transformReactJSXDevelopment__default = /* @__PURE__ */ _interopDefaultLegacy(transformReactJSXDevelopment);
    var transformReactDisplayName__default = /* @__PURE__ */ _interopDefaultLegacy(transformReactDisplayName);
    var transformReactPure__default = /* @__PURE__ */ _interopDefaultLegacy(transformReactPure);
    new helperValidatorOption.OptionValidator("@babel/preset-react");
    function normalizeOptions(options = {}) {
      {
        let {
          pragma,
          pragmaFrag
        } = options;
        const {
          pure,
          throwIfNamespace = true,
          runtime = "classic",
          importSource,
          useBuiltIns,
          useSpread
        } = options;
        if (runtime === "classic") {
          pragma = pragma || "React.createElement";
          pragmaFrag = pragmaFrag || "React.Fragment";
        }
        const development2 = !!options.development;
        return {
          development: development2,
          importSource,
          pragma,
          pragmaFrag,
          pure,
          runtime,
          throwIfNamespace,
          useBuiltIns,
          useSpread
        };
      }
    }
    var index2 = helperPluginUtils.declarePreset((api, opts) => {
      api.assertVersion(7);
      const {
        development: development2,
        importSource,
        pragma,
        pragmaFrag,
        pure,
        runtime,
        throwIfNamespace
      } = normalizeOptions(opts);
      return {
        plugins: [[development2 ? transformReactJSXDevelopment__default["default"] : transformReactJSX__default["default"], {
          importSource,
          pragma,
          pragmaFrag,
          runtime,
          throwIfNamespace,
          pure,
          useBuiltIns: !!opts.useBuiltIns,
          useSpread: opts.useSpread
        }], transformReactDisplayName__default["default"], pure !== false && transformReactPure__default["default"]].filter(Boolean)
      };
    });
    exports["default"] = index2;
  }
});

// src/index.ts
var src_exports = {};
__export(src_exports, {
  SEPARATOR: () => SEPARATOR,
  compile: () => compile2,
  compileSync: () => compileSync2,
  genBabel: () => genBabel,
  plugin: () => plugin,
  postprocess: () => postprocess2,
  wrapperJs: () => wrapperJs
});
module.exports = __toCommonJS(src_exports);

// node_modules/bail/index.js
function bail(error) {
  if (error) {
    throw error;
  }
}

// node_modules/unified/lib/index.js
var import_is_buffer2 = __toESM(require_is_buffer(), 1);
var import_extend = __toESM(require_extend(), 1);

// node_modules/is-plain-obj/index.js
function isPlainObject(value2) {
  if (typeof value2 !== "object" || value2 === null) {
    return false;
  }
  const prototype = Object.getPrototypeOf(value2);
  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value2) && !(Symbol.iterator in value2);
}

// node_modules/trough/index.js
function trough() {
  const fns = [];
  const pipeline = { run, use };
  return pipeline;
  function run(...values) {
    let middlewareIndex = -1;
    const callback = values.pop();
    if (typeof callback !== "function") {
      throw new TypeError("Expected function as last argument, not " + callback);
    }
    next(null, ...values);
    function next(error, ...output) {
      const fn = fns[++middlewareIndex];
      let index2 = -1;
      if (error) {
        callback(error);
        return;
      }
      while (++index2 < values.length) {
        if (output[index2] === null || output[index2] === void 0) {
          output[index2] = values[index2];
        }
      }
      values = output;
      if (fn) {
        wrap(fn, next)(...output);
      } else {
        callback(null, ...output);
      }
    }
  }
  function use(middelware) {
    if (typeof middelware !== "function") {
      throw new TypeError(
        "Expected `middelware` to be a function, not " + middelware
      );
    }
    fns.push(middelware);
    return pipeline;
  }
}
function wrap(middleware, callback) {
  let called;
  return wrapped;
  function wrapped(...parameters) {
    const fnExpectsCallback = middleware.length > parameters.length;
    let result;
    if (fnExpectsCallback) {
      parameters.push(done);
    }
    try {
      result = middleware.apply(this, parameters);
    } catch (error) {
      const exception = (
        /** @type {Error} */
        error
      );
      if (fnExpectsCallback && called) {
        throw exception;
      }
      return done(exception);
    }
    if (!fnExpectsCallback) {
      if (result instanceof Promise) {
        result.then(then, done);
      } else if (result instanceof Error) {
        done(result);
      } else {
        then(result);
      }
    }
  }
  function done(error, ...output) {
    if (!called) {
      called = true;
      callback(error, ...output);
    }
  }
  function then(value2) {
    done(null, value2);
  }
}

// node_modules/vfile/lib/index.js
var import_is_buffer = __toESM(require_is_buffer(), 1);

// node_modules/unist-util-stringify-position/lib/index.js
function stringifyPosition(value2) {
  if (!value2 || typeof value2 !== "object") {
    return "";
  }
  if ("position" in value2 || "type" in value2) {
    return position(value2.position);
  }
  if ("start" in value2 || "end" in value2) {
    return position(value2);
  }
  if ("line" in value2 || "column" in value2) {
    return point(value2);
  }
  return "";
}
function point(point4) {
  return index(point4 && point4.line) + ":" + index(point4 && point4.column);
}
function position(pos2) {
  return point(pos2 && pos2.start) + "-" + point(pos2 && pos2.end);
}
function index(value2) {
  return value2 && typeof value2 === "number" ? value2 : 1;
}

// node_modules/vfile-message/lib/index.js
var VFileMessage = class extends Error {
  /**
   * Create a message for `reason` at `place` from `origin`.
   *
   * When an error is passed in as `reason`, the `stack` is copied.
   *
   * @param {string | Error | VFileMessage} reason
   *   Reason for message, uses the stack and message of the error if given.
   *
   *   > 👉 **Note**: you should use markdown.
   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
   *   Place in file where the message occurred.
   * @param {string | null | undefined} [origin]
   *   Place in code where the message originates (example:
   *   `'my-package:my-rule'` or `'my-rule'`).
   * @returns
   *   Instance of `VFileMessage`.
   */
  // To do: next major: expose `undefined` everywhere instead of `null`.
  constructor(reason, place, origin) {
    const parts = [null, null];
    let position3 = {
      // @ts-expect-error: we always follows the structure of `position`.
      start: { line: null, column: null },
      // @ts-expect-error: "
      end: { line: null, column: null }
    };
    super();
    if (typeof place === "string") {
      origin = place;
      place = void 0;
    }
    if (typeof origin === "string") {
      const index2 = origin.indexOf(":");
      if (index2 === -1) {
        parts[1] = origin;
      } else {
        parts[0] = origin.slice(0, index2);
        parts[1] = origin.slice(index2 + 1);
      }
    }
    if (place) {
      if ("type" in place || "position" in place) {
        if (place.position) {
          position3 = place.position;
        }
      } else if ("start" in place || "end" in place) {
        position3 = place;
      } else if ("line" in place || "column" in place) {
        position3.start = place;
      }
    }
    this.name = stringifyPosition(place) || "1:1";
    this.message = typeof reason === "object" ? reason.message : reason;
    this.stack = "";
    if (typeof reason === "object" && reason.stack) {
      this.stack = reason.stack;
    }
    this.reason = this.message;
    this.fatal;
    this.line = position3.start.line;
    this.column = position3.start.column;
    this.position = position3;
    this.source = parts[0];
    this.ruleId = parts[1];
    this.file;
    this.actual;
    this.expected;
    this.url;
    this.note;
  }
};
VFileMessage.prototype.file = "";
VFileMessage.prototype.name = "";
VFileMessage.prototype.reason = "";
VFileMessage.prototype.message = "";
VFileMessage.prototype.stack = "";
VFileMessage.prototype.fatal = null;
VFileMessage.prototype.column = null;
VFileMessage.prototype.line = null;
VFileMessage.prototype.source = null;
VFileMessage.prototype.ruleId = null;
VFileMessage.prototype.position = null;

// node_modules/vfile/lib/minpath.js
var import_path = __toESM(require("path"), 1);

// node_modules/vfile/lib/minproc.js
var import_process = __toESM(require("process"), 1);

// node_modules/vfile/lib/minurl.js
var import_url = require("url");

// node_modules/vfile/lib/minurl.shared.js
function isUrl(fileUrlOrPath) {
  return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable.
  fileUrlOrPath.href && // @ts-expect-error: indexable.
  fileUrlOrPath.origin;
}

// node_modules/vfile/lib/index.js
var order = ["history", "path", "basename", "stem", "extname", "dirname"];
var VFile = class {
  /**
   * Create a new virtual file.
   *
   * `options` is treated as:
   *
   * *   `string` or `Buffer` — `{value: options}`
   * *   `URL` — `{path: options}`
   * *   `VFile` — shallow copies its data over to the new file
   * *   `object` — all fields are shallow copied over to the new file
   *
   * Path related fields are set in the following order (least specific to
   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
   * `dirname`.
   *
   * You cannot set `dirname` or `extname` without setting either `history`,
   * `path`, `basename`, or `stem` too.
   *
   * @param {Compatible | null | undefined} [value]
   *   File value.
   * @returns
   *   New instance.
   */
  constructor(value2) {
    let options;
    if (!value2) {
      options = {};
    } else if (typeof value2 === "string" || buffer(value2)) {
      options = { value: value2 };
    } else if (isUrl(value2)) {
      options = { path: value2 };
    } else {
      options = value2;
    }
    this.data = {};
    this.messages = [];
    this.history = [];
    this.cwd = import_process.default.cwd();
    this.value;
    this.stored;
    this.result;
    this.map;
    let index2 = -1;
    while (++index2 < order.length) {
      const prop2 = order[index2];
      if (prop2 in options && options[prop2] !== void 0 && options[prop2] !== null) {
        this[prop2] = prop2 === "history" ? [...options[prop2]] : options[prop2];
      }
    }
    let prop;
    for (prop in options) {
      if (!order.includes(prop)) {
        this[prop] = options[prop];
      }
    }
  }
  /**
   * Get the full path (example: `'~/index.min.js'`).
   *
   * @returns {string}
   */
  get path() {
    return this.history[this.history.length - 1];
  }
  /**
   * Set the full path (example: `'~/index.min.js'`).
   *
   * Cannot be nullified.
   * You can set a file URL (a `URL` object with a `file:` protocol) which will
   * be turned into a path with `url.fileURLToPath`.
   *
   * @param {string | URL} path
   */
  set path(path) {
    if (isUrl(path)) {
      path = (0, import_url.fileURLToPath)(path);
    }
    assertNonEmpty(path, "path");
    if (this.path !== path) {
      this.history.push(path);
    }
  }
  /**
   * Get the parent path (example: `'~'`).
   */
  get dirname() {
    return typeof this.path === "string" ? import_path.default.dirname(this.path) : void 0;
  }
  /**
   * Set the parent path (example: `'~'`).
   *
   * Cannot be set if there’s no `path` yet.
   */
  set dirname(dirname) {
    assertPath(this.basename, "dirname");
    this.path = import_path.default.join(dirname || "", this.basename);
  }
  /**
   * Get the basename (including extname) (example: `'index.min.js'`).
   */
  get basename() {
    return typeof this.path === "string" ? import_path.default.basename(this.path) : void 0;
  }
  /**
   * Set basename (including extname) (`'index.min.js'`).
   *
   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
   * on windows).
   * Cannot be nullified (use `file.path = file.dirname` instead).
   */
  set basename(basename) {
    assertNonEmpty(basename, "basename");
    assertPart(basename, "basename");
    this.path = import_path.default.join(this.dirname || "", basename);
  }
  /**
   * Get the extname (including dot) (example: `'.js'`).
   */
  get extname() {
    return typeof this.path === "string" ? import_path.default.extname(this.path) : void 0;
  }
  /**
   * Set the extname (including dot) (example: `'.js'`).
   *
   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
   * on windows).
   * Cannot be set if there’s no `path` yet.
   */
  set extname(extname) {
    assertPart(extname, "extname");
    assertPath(this.dirname, "extname");
    if (extname) {
      if (extname.charCodeAt(0) !== 46) {
        throw new Error("`extname` must start with `.`");
      }
      if (extname.includes(".", 1)) {
        throw new Error("`extname` cannot contain multiple dots");
      }
    }
    this.path = import_path.default.join(this.dirname, this.stem + (extname || ""));
  }
  /**
   * Get the stem (basename w/o extname) (example: `'index.min'`).
   */
  get stem() {
    return typeof this.path === "string" ? import_path.default.basename(this.path, this.extname) : void 0;
  }
  /**
   * Set the stem (basename w/o extname) (example: `'index.min'`).
   *
   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
   * on windows).
   * Cannot be nullified (use `file.path = file.dirname` instead).
   */
  set stem(stem) {
    assertNonEmpty(stem, "stem");
    assertPart(stem, "stem");
    this.path = import_path.default.join(this.dirname || "", stem + (this.extname || ""));
  }
  /**
   * Serialize the file.
   *
   * @param {BufferEncoding | null | undefined} [encoding='utf8']
   *   Character encoding to understand `value` as when it’s a `Buffer`
   *   (default: `'utf8'`).
   * @returns {string}
   *   Serialized file.
   */
  toString(encoding) {
    return (this.value || "").toString(encoding || void 0);
  }
  /**
   * Create a warning message associated with the file.
   *
   * Its `fatal` is set to `false` and `file` is set to the current file path.
   * Its added to `file.messages`.
   *
   * @param {string | Error | VFileMessage} reason
   *   Reason for message, uses the stack and message of the error if given.
   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
   *   Place in file where the message occurred.
   * @param {string | null | undefined} [origin]
   *   Place in code where the message originates (example:
   *   `'my-package:my-rule'` or `'my-rule'`).
   * @returns {VFileMessage}
   *   Message.
   */
  message(reason, place, origin) {
    const message = new VFileMessage(reason, place, origin);
    if (this.path) {
      message.name = this.path + ":" + message.name;
      message.file = this.path;
    }
    message.fatal = false;
    this.messages.push(message);
    return message;
  }
  /**
   * Create an info message associated with the file.
   *
   * Its `fatal` is set to `null` and `file` is set to the current file path.
   * Its added to `file.messages`.
   *
   * @param {string | Error | VFileMessage} reason
   *   Reason for message, uses the stack and message of the error if given.
   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
   *   Place in file where the message occurred.
   * @param {string | null | undefined} [origin]
   *   Place in code where the message originates (example:
   *   `'my-package:my-rule'` or `'my-rule'`).
   * @returns {VFileMessage}
   *   Message.
   */
  info(reason, place, origin) {
    const message = this.message(reason, place, origin);
    message.fatal = null;
    return message;
  }
  /**
   * Create a fatal error associated with the file.
   *
   * Its `fatal` is set to `true` and `file` is set to the current file path.
   * Its added to `file.messages`.
   *
   * > 👉 **Note**: a fatal error means that a file is no longer processable.
   *
   * @param {string | Error | VFileMessage} reason
   *   Reason for message, uses the stack and message of the error if given.
   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
   *   Place in file where the message occurred.
   * @param {string | null | undefined} [origin]
   *   Place in code where the message originates (example:
   *   `'my-package:my-rule'` or `'my-rule'`).
   * @returns {never}
   *   Message.
   * @throws {VFileMessage}
   *   Message.
   */
  fail(reason, place, origin) {
    const message = this.message(reason, place, origin);
    message.fatal = true;
    throw message;
  }
};
function assertPart(part, name2) {
  if (part && part.includes(import_path.default.sep)) {
    throw new Error(
      "`" + name2 + "` cannot be a path: did not expect `" + import_path.default.sep + "`"
    );
  }
}
function assertNonEmpty(part, name2) {
  if (!part) {
    throw new Error("`" + name2 + "` cannot be empty");
  }
}
function assertPath(path, name2) {
  if (!path) {
    throw new Error("Setting `" + name2 + "` requires `path` to be set too");
  }
}
function buffer(value2) {
  return (0, import_is_buffer.default)(value2);
}

// node_modules/unified/lib/index.js
var unified = base().freeze();
var own = {}.hasOwnProperty;
function base() {
  const transformers = trough();
  const attachers = [];
  let namespace = {};
  let frozen;
  let freezeIndex = -1;
  processor.data = data3;
  processor.Parser = void 0;
  processor.Compiler = void 0;
  processor.freeze = freeze;
  processor.attachers = attachers;
  processor.use = use;
  processor.parse = parse9;
  processor.stringify = stringify6;
  processor.run = run;
  processor.runSync = runSync;
  processor.process = process3;
  processor.processSync = processSync;
  return processor;
  function processor() {
    const destination = base();
    let index2 = -1;
    while (++index2 < attachers.length) {
      destination.use(...attachers[index2]);
    }
    destination.data((0, import_extend.default)(true, {}, namespace));
    return destination;
  }
  function data3(key2, value2) {
    if (typeof key2 === "string") {
      if (arguments.length === 2) {
        assertUnfrozen("data", frozen);
        namespace[key2] = value2;
        return processor;
      }
      return own.call(namespace, key2) && namespace[key2] || null;
    }
    if (key2) {
      assertUnfrozen("data", frozen);
      namespace = key2;
      return processor;
    }
    return namespace;
  }
  function freeze() {
    if (frozen) {
      return processor;
    }
    while (++freezeIndex < attachers.length) {
      const [attacher, ...options] = attachers[freezeIndex];
      if (options[0] === false) {
        continue;
      }
      if (options[0] === true) {
        options[0] = void 0;
      }
      const transformer = attacher.call(processor, ...options);
      if (typeof transformer === "function") {
        transformers.use(transformer);
      }
    }
    frozen = true;
    freezeIndex = Number.POSITIVE_INFINITY;
    return processor;
  }
  function use(value2, ...options) {
    let settings;
    assertUnfrozen("use", frozen);
    if (value2 === null || value2 === void 0) {
    } else if (typeof value2 === "function") {
      addPlugin(value2, ...options);
    } else if (typeof value2 === "object") {
      if (Array.isArray(value2)) {
        addList(value2);
      } else {
        addPreset(value2);
      }
    } else {
      throw new TypeError("Expected usable value, not `" + value2 + "`");
    }
    if (settings) {
      namespace.settings = Object.assign(namespace.settings || {}, settings);
    }
    return processor;
    function add(value3) {
      if (typeof value3 === "function") {
        addPlugin(value3);
      } else if (typeof value3 === "object") {
        if (Array.isArray(value3)) {
          const [plugin2, ...options2] = value3;
          addPlugin(plugin2, ...options2);
        } else {
          addPreset(value3);
        }
      } else {
        throw new TypeError("Expected usable value, not `" + value3 + "`");
      }
    }
    function addPreset(result) {
      addList(result.plugins);
      if (result.settings) {
        settings = Object.assign(settings || {}, result.settings);
      }
    }
    function addList(plugins) {
      let index2 = -1;
      if (plugins === null || plugins === void 0) {
      } else if (Array.isArray(plugins)) {
        while (++index2 < plugins.length) {
          const thing = plugins[index2];
          add(thing);
        }
      } else {
        throw new TypeError("Expected a list of plugins, not `" + plugins + "`");
      }
    }
    function addPlugin(plugin2, value3) {
      let index2 = -1;
      let entry;
      while (++index2 < attachers.length) {
        if (attachers[index2][0] === plugin2) {
          entry = attachers[index2];
          break;
        }
      }
      if (entry) {
        if (isPlainObject(entry[1]) && isPlainObject(value3)) {
          value3 = (0, import_extend.default)(true, entry[1], value3);
        }
        entry[1] = value3;
      } else {
        attachers.push([...arguments]);
      }
    }
  }
  function parse9(doc) {
    processor.freeze();
    const file = vfile(doc);
    const Parser5 = processor.Parser;
    assertParser("parse", Parser5);
    if (newable(Parser5, "parse")) {
      return new Parser5(String(file), file).parse();
    }
    return Parser5(String(file), file);
  }
  function stringify6(node2, doc) {
    processor.freeze();
    const file = vfile(doc);
    const Compiler = processor.Compiler;
    assertCompiler("stringify", Compiler);
    assertNode(node2);
    if (newable(Compiler, "compile")) {
      return new Compiler(node2, file).compile();
    }
    return Compiler(node2, file);
  }
  function run(node2, doc, callback) {
    assertNode(node2);
    processor.freeze();
    if (!callback && typeof doc === "function") {
      callback = doc;
      doc = void 0;
    }
    if (!callback) {
      return new Promise(executor);
    }
    executor(null, callback);
    function executor(resolve, reject) {
      transformers.run(node2, vfile(doc), done);
      function done(error, tree, file) {
        tree = tree || node2;
        if (error) {
          reject(error);
        } else if (resolve) {
          resolve(tree);
        } else {
          callback(null, tree, file);
        }
      }
    }
  }
  function runSync(node2, file) {
    let result;
    let complete;
    processor.run(node2, file, done);
    assertDone("runSync", "run", complete);
    return result;
    function done(error, tree) {
      bail(error);
      result = tree;
      complete = true;
    }
  }
  function process3(doc, callback) {
    processor.freeze();
    assertParser("process", processor.Parser);
    assertCompiler("process", processor.Compiler);
    if (!callback) {
      return new Promise(executor);
    }
    executor(null, callback);
    function executor(resolve, reject) {
      const file = vfile(doc);
      processor.run(processor.parse(file), file, (error, tree, file2) => {
        if (error || !tree || !file2) {
          done(error);
        } else {
          const result = processor.stringify(tree, file2);
          if (result === void 0 || result === null) {
          } else if (looksLikeAVFileValue(result)) {
            file2.value = result;
          } else {
            file2.result = result;
          }
          done(error, file2);
        }
      });
      function done(error, file2) {
        if (error || !file2) {
          reject(error);
        } else if (resolve) {
          resolve(file2);
        } else {
          callback(null, file2);
        }
      }
    }
  }
  function processSync(doc) {
    let complete;
    processor.freeze();
    assertParser("processSync", processor.Parser);
    assertCompiler("processSync", processor.Compiler);
    const file = vfile(doc);
    processor.process(file, done);
    assertDone("processSync", "process", complete);
    return file;
    function done(error) {
      complete = true;
      bail(error);
    }
  }
}
function newable(value2, name2) {
  return typeof value2 === "function" && // Prototypes do exist.
  // type-coverage:ignore-next-line
  value2.prototype && // A function with keys in its prototype is probably a constructor.
  // Classes’ prototype methods are not enumerable, so we check if some value
  // exists in the prototype.
  // type-coverage:ignore-next-line
  (keys(value2.prototype) || name2 in value2.prototype);
}
function keys(value2) {
  let key2;
  for (key2 in value2) {
    if (own.call(value2, key2)) {
      return true;
    }
  }
  return false;
}
function assertParser(name2, value2) {
  if (typeof value2 !== "function") {
    throw new TypeError("Cannot `" + name2 + "` without `Parser`");
  }
}
function assertCompiler(name2, value2) {
  if (typeof value2 !== "function") {
    throw new TypeError("Cannot `" + name2 + "` without `Compiler`");
  }
}
function assertUnfrozen(name2, frozen) {
  if (frozen) {
    throw new Error(
      "Cannot call `" + name2 + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`."
    );
  }
}
function assertNode(node2) {
  if (!isPlainObject(node2) || typeof node2.type !== "string") {
    throw new TypeError("Expected node, got `" + node2 + "`");
  }
}
function assertDone(name2, asyncName, complete) {
  if (!complete) {
    throw new Error(
      "`" + name2 + "` finished async. Use `" + asyncName + "` instead"
    );
  }
}
function vfile(value2) {
  return looksLikeAVFile(value2) ? value2 : new VFile(value2);
}
function looksLikeAVFile(value2) {
  return Boolean(
    value2 && typeof value2 === "object" && "message" in value2 && "messages" in value2
  );
}
function looksLikeAVFileValue(value2) {
  return typeof value2 === "string" || (0, import_is_buffer2.default)(value2);
}

// node_modules/acorn/dist/acorn.mjs
var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
var astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191];
var nonASCIIidentifierChars = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
var reservedWords = {
  3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
  5: "class enum extends super const export import",
  6: "enum",
  strict: "implements interface let package private protected public static yield",
  strictBind: "eval arguments"
};
var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
var keywords$1 = {
  5: ecma5AndLessKeywords,
  "5module": ecma5AndLessKeywords + " export import",
  6: ecma5AndLessKeywords + " const class extends export import super"
};
var keywordRelationalOperator = /^in(stanceof)?$/;
var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
function isInAstralSet(code2, set) {
  var pos2 = 65536;
  for (var i = 0; i < set.length; i += 2) {
    pos2 += set[i];
    if (pos2 > code2) {
      return false;
    }
    pos2 += set[i + 1];
    if (pos2 >= code2) {
      return true;
    }
  }
  return false;
}
function isIdentifierStart(code2, astral) {
  if (code2 < 65) {
    return code2 === 36;
  }
  if (code2 < 91) {
    return true;
  }
  if (code2 < 97) {
    return code2 === 95;
  }
  if (code2 < 123) {
    return true;
  }
  if (code2 <= 65535) {
    return code2 >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code2));
  }
  if (astral === false) {
    return false;
  }
  return isInAstralSet(code2, astralIdentifierStartCodes);
}
function isIdentifierChar(code2, astral) {
  if (code2 < 48) {
    return code2 === 36;
  }
  if (code2 < 58) {
    return true;
  }
  if (code2 < 65) {
    return false;
  }
  if (code2 < 91) {
    return true;
  }
  if (code2 < 97) {
    return code2 === 95;
  }
  if (code2 < 123) {
    return true;
  }
  if (code2 <= 65535) {
    return code2 >= 170 && nonASCIIidentifier.test(String.fromCharCode(code2));
  }
  if (astral === false) {
    return false;
  }
  return isInAstralSet(code2, astralIdentifierStartCodes) || isInAstralSet(code2, astralIdentifierCodes);
}
var TokenType = function TokenType2(label, conf) {
  if (conf === void 0)
    conf = {};
  this.label = label;
  this.keyword = conf.keyword;
  this.beforeExpr = !!conf.beforeExpr;
  this.startsExpr = !!conf.startsExpr;
  this.isLoop = !!conf.isLoop;
  this.isAssign = !!conf.isAssign;
  this.prefix = !!conf.prefix;
  this.postfix = !!conf.postfix;
  this.binop = conf.binop || null;
  this.updateContext = null;
};
function binop(name2, prec) {
  return new TokenType(name2, { beforeExpr: true, binop: prec });
}
var beforeExpr = { beforeExpr: true };
var startsExpr = { startsExpr: true };
var keywords = {};
function kw(name2, options) {
  if (options === void 0)
    options = {};
  options.keyword = name2;
  return keywords[name2] = new TokenType(name2, options);
}
var types$1 = {
  num: new TokenType("num", startsExpr),
  regexp: new TokenType("regexp", startsExpr),
  string: new TokenType("string", startsExpr),
  name: new TokenType("name", startsExpr),
  privateId: new TokenType("privateId", startsExpr),
  eof: new TokenType("eof"),
  // Punctuation token types.
  bracketL: new TokenType("[", { beforeExpr: true, startsExpr: true }),
  bracketR: new TokenType("]"),
  braceL: new TokenType("{", { beforeExpr: true, startsExpr: true }),
  braceR: new TokenType("}"),
  parenL: new TokenType("(", { beforeExpr: true, startsExpr: true }),
  parenR: new TokenType(")"),
  comma: new TokenType(",", beforeExpr),
  semi: new TokenType(";", beforeExpr),
  colon: new TokenType(":", beforeExpr),
  dot: new TokenType("."),
  question: new TokenType("?", beforeExpr),
  questionDot: new TokenType("?."),
  arrow: new TokenType("=>", beforeExpr),
  template: new TokenType("template"),
  invalidTemplate: new TokenType("invalidTemplate"),
  ellipsis: new TokenType("...", beforeExpr),
  backQuote: new TokenType("`", startsExpr),
  dollarBraceL: new TokenType("${", { beforeExpr: true, startsExpr: true }),
  // Operators. These carry several kinds of properties to help the
  // parser use them properly (the presence of these properties is
  // what categorizes them as operators).
  //
  // `binop`, when present, specifies that this operator is a binary
  // operator, and will refer to its precedence.
  //
  // `prefix` and `postfix` mark the operator as a prefix or postfix
  // unary operator.
  //
  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
  // binary operators with a very low precedence, that should result
  // in AssignmentExpression nodes.
  eq: new TokenType("=", { beforeExpr: true, isAssign: true }),
  assign: new TokenType("_=", { beforeExpr: true, isAssign: true }),
  incDec: new TokenType("++/--", { prefix: true, postfix: true, startsExpr: true }),
  prefix: new TokenType("!/~", { beforeExpr: true, prefix: true, startsExpr: true }),
  logicalOR: binop("||", 1),
  logicalAND: binop("&&", 2),
  bitwiseOR: binop("|", 3),
  bitwiseXOR: binop("^", 4),
  bitwiseAND: binop("&", 5),
  equality: binop("==/!=/===/!==", 6),
  relational: binop("</>/<=/>=", 7),
  bitShift: binop("<</>>/>>>", 8),
  plusMin: new TokenType("+/-", { beforeExpr: true, binop: 9, prefix: true, startsExpr: true }),
  modulo: binop("%", 10),
  star: binop("*", 10),
  slash: binop("/", 10),
  starstar: new TokenType("**", { beforeExpr: true }),
  coalesce: binop("??", 1),
  // Keyword token types.
  _break: kw("break"),
  _case: kw("case", beforeExpr),
  _catch: kw("catch"),
  _continue: kw("continue"),
  _debugger: kw("debugger"),
  _default: kw("default", beforeExpr),
  _do: kw("do", { isLoop: true, beforeExpr: true }),
  _else: kw("else", beforeExpr),
  _finally: kw("finally"),
  _for: kw("for", { isLoop: true }),
  _function: kw("function", startsExpr),
  _if: kw("if"),
  _return: kw("return", beforeExpr),
  _switch: kw("switch"),
  _throw: kw("throw", beforeExpr),
  _try: kw("try"),
  _var: kw("var"),
  _const: kw("const"),
  _while: kw("while", { isLoop: true }),
  _with: kw("with"),
  _new: kw("new", { beforeExpr: true, startsExpr: true }),
  _this: kw("this", startsExpr),
  _super: kw("super", startsExpr),
  _class: kw("class", startsExpr),
  _extends: kw("extends", beforeExpr),
  _export: kw("export"),
  _import: kw("import", startsExpr),
  _null: kw("null", startsExpr),
  _true: kw("true", startsExpr),
  _false: kw("false", startsExpr),
  _in: kw("in", { beforeExpr: true, binop: 7 }),
  _instanceof: kw("instanceof", { beforeExpr: true, binop: 7 }),
  _typeof: kw("typeof", { beforeExpr: true, prefix: true, startsExpr: true }),
  _void: kw("void", { beforeExpr: true, prefix: true, startsExpr: true }),
  _delete: kw("delete", { beforeExpr: true, prefix: true, startsExpr: true })
};
var lineBreak = /\r\n?|\n|\u2028|\u2029/;
var lineBreakG = new RegExp(lineBreak.source, "g");
function isNewLine(code2) {
  return code2 === 10 || code2 === 13 || code2 === 8232 || code2 === 8233;
}
function nextLineBreak(code2, from, end) {
  if (end === void 0)
    end = code2.length;
  for (var i = from; i < end; i++) {
    var next = code2.charCodeAt(i);
    if (isNewLine(next)) {
      return i < end - 1 && next === 13 && code2.charCodeAt(i + 1) === 10 ? i + 2 : i + 1;
    }
  }
  return -1;
}
var nonASCIIwhitespace = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
var ref = Object.prototype;
var hasOwnProperty = ref.hasOwnProperty;
var toString = ref.toString;
var hasOwn = Object.hasOwn || function(obj, propName) {
  return hasOwnProperty.call(obj, propName);
};
var isArray = Array.isArray || function(obj) {
  return toString.call(obj) === "[object Array]";
};
function wordsRegexp(words) {
  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$");
}
function codePointToString(code2) {
  if (code2 <= 65535) {
    return String.fromCharCode(code2);
  }
  code2 -= 65536;
  return String.fromCharCode((code2 >> 10) + 55296, (code2 & 1023) + 56320);
}
var loneSurrogate = /(?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/;
var Position = function Position2(line2, col) {
  this.line = line2;
  this.column = col;
};
Position.prototype.offset = function offset(n) {
  return new Position(this.line, this.column + n);
};
var SourceLocation = function SourceLocation2(p, start3, end) {
  this.start = start3;
  this.end = end;
  if (p.sourceFile !== null) {
    this.source = p.sourceFile;
  }
};
function getLineInfo(input, offset3) {
  for (var line2 = 1, cur = 0; ; ) {
    var nextBreak = nextLineBreak(input, cur, offset3);
    if (nextBreak < 0) {
      return new Position(line2, offset3 - cur);
    }
    ++line2;
    cur = nextBreak;
  }
}
var defaultOptions = {
  // `ecmaVersion` indicates the ECMAScript version to parse. Must be
  // either 3, 5, 6 (or 2015), 7 (2016), 8 (2017), 9 (2018), 10
  // (2019), 11 (2020), 12 (2021), 13 (2022), 14 (2023), or `"latest"`
  // (the latest version the library supports). This influences
  // support for strict mode, the set of reserved words, and support
  // for new syntax features.
  ecmaVersion: null,
  // `sourceType` indicates the mode the code should be parsed in.
  // Can be either `"script"` or `"module"`. This influences global
  // strict mode and parsing of `import` and `export` declarations.
  sourceType: "script",
  // `onInsertedSemicolon` can be a callback that will be called
  // when a semicolon is automatically inserted. It will be passed
  // the position of the comma as an offset, and if `locations` is
  // enabled, it is given the location as a `{line, column}` object
  // as second argument.
  onInsertedSemicolon: null,
  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
  // trailing commas.
  onTrailingComma: null,
  // By default, reserved words are only enforced if ecmaVersion >= 5.
  // Set `allowReserved` to a boolean value to explicitly turn this on
  // an off. When this option has the value "never", reserved words
  // and keywords can also not be used as property names.
  allowReserved: null,
  // When enabled, a return at the top level is not considered an
  // error.
  allowReturnOutsideFunction: false,
  // When enabled, import/export statements are not constrained to
  // appearing at the top of the program, and an import.meta expression
  // in a script isn't considered an error.
  allowImportExportEverywhere: false,
  // By default, await identifiers are allowed to appear at the top-level scope only if ecmaVersion >= 2022.
  // When enabled, await identifiers are allowed to appear at the top-level scope,
  // but they are still not allowed in non-async functions.
  allowAwaitOutsideFunction: null,
  // When enabled, super identifiers are not constrained to
  // appearing in methods and do not raise an error when they appear elsewhere.
  allowSuperOutsideMethod: null,
  // When enabled, hashbang directive in the beginning of file is
  // allowed and treated as a line comment. Enabled by default when
  // `ecmaVersion` >= 2023.
  allowHashBang: false,
  // When `locations` is on, `loc` properties holding objects with
  // `start` and `end` properties in `{line, column}` form (with
  // line being 1-based and column 0-based) will be attached to the
  // nodes.
  locations: false,
  // A function can be passed as `onToken` option, which will
  // cause Acorn to call that function with object in the same
  // format as tokens returned from `tokenizer().getToken()`. Note
  // that you are not allowed to call the parser from the
  // callback—that will corrupt its internal state.
  onToken: null,
  // A function can be passed as `onComment` option, which will
  // cause Acorn to call that function with `(block, text, start,
  // end)` parameters whenever a comment is skipped. `block` is a
  // boolean indicating whether this is a block (`/* */`) comment,
  // `text` is the content of the comment, and `start` and `end` are
  // character offsets that denote the start and end of the comment.
  // When the `locations` option is on, two more parameters are
  // passed, the full `{line, column}` locations of the start and
  // end of the comments. Note that you are not allowed to call the
  // parser from the callback—that will corrupt its internal state.
  onComment: null,
  // Nodes have their start and end characters offsets recorded in
  // `start` and `end` properties (directly on the node, rather than
  // the `loc` object, which holds line/column data. To also add a
  // [semi-standardized][range] `range` property holding a `[start,
  // end]` array with the same numbers, set the `ranges` option to
  // `true`.
  //
  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
  ranges: false,
  // It is possible to parse multiple files into a single AST by
  // passing the tree produced by parsing the first file as
  // `program` option in subsequent parses. This will add the
  // toplevel forms of the parsed file to the `Program` (top) node
  // of an existing parse tree.
  program: null,
  // When `locations` is on, you can pass this to record the source
  // file in every node's `loc` object.
  sourceFile: null,
  // This value, if given, is stored in every node, whether
  // `locations` is on or off.
  directSourceFile: null,
  // When enabled, parenthesized expressions are represented by
  // (non-standard) ParenthesizedExpression nodes
  preserveParens: false
};
var warnedAboutEcmaVersion = false;
function getOptions(opts) {
  var options = {};
  for (var opt in defaultOptions) {
    options[opt] = opts && hasOwn(opts, opt) ? opts[opt] : defaultOptions[opt];
  }
  if (options.ecmaVersion === "latest") {
    options.ecmaVersion = 1e8;
  } else if (options.ecmaVersion == null) {
    if (!warnedAboutEcmaVersion && typeof console === "object" && console.warn) {
      warnedAboutEcmaVersion = true;
      console.warn("Since Acorn 8.0.0, options.ecmaVersion is required.\nDefaulting to 2020, but this will stop working in the future.");
    }
    options.ecmaVersion = 11;
  } else if (options.ecmaVersion >= 2015) {
    options.ecmaVersion -= 2009;
  }
  if (options.allowReserved == null) {
    options.allowReserved = options.ecmaVersion < 5;
  }
  if (!opts || opts.allowHashBang == null) {
    options.allowHashBang = options.ecmaVersion >= 14;
  }
  if (isArray(options.onToken)) {
    var tokens = options.onToken;
    options.onToken = function(token2) {
      return tokens.push(token2);
    };
  }
  if (isArray(options.onComment)) {
    options.onComment = pushComment(options, options.onComment);
  }
  return options;
}
function pushComment(options, array) {
  return function(block, text5, start3, end, startLoc, endLoc) {
    var comment2 = {
      type: block ? "Block" : "Line",
      value: text5,
      start: start3,
      end
    };
    if (options.locations) {
      comment2.loc = new SourceLocation(this, startLoc, endLoc);
    }
    if (options.ranges) {
      comment2.range = [start3, end];
    }
    array.push(comment2);
  };
}
var SCOPE_TOP = 1;
var SCOPE_FUNCTION = 2;
var SCOPE_ASYNC = 4;
var SCOPE_GENERATOR = 8;
var SCOPE_ARROW = 16;
var SCOPE_SIMPLE_CATCH = 32;
var SCOPE_SUPER = 64;
var SCOPE_DIRECT_SUPER = 128;
var SCOPE_CLASS_STATIC_BLOCK = 256;
var SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK;
function functionFlags(async, generator) {
  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0);
}
var BIND_NONE = 0;
var BIND_VAR = 1;
var BIND_LEXICAL = 2;
var BIND_FUNCTION = 3;
var BIND_SIMPLE_CATCH = 4;
var BIND_OUTSIDE = 5;
var Parser = function Parser2(options, input, startPos) {
  this.options = options = getOptions(options);
  this.sourceFile = options.sourceFile;
  this.keywords = wordsRegexp(keywords$1[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
  var reserved = "";
  if (options.allowReserved !== true) {
    reserved = reservedWords[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3];
    if (options.sourceType === "module") {
      reserved += " await";
    }
  }
  this.reservedWords = wordsRegexp(reserved);
  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
  this.reservedWordsStrict = wordsRegexp(reservedStrict);
  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords.strictBind);
  this.input = String(input);
  this.containsEsc = false;
  if (startPos) {
    this.pos = startPos;
    this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
  } else {
    this.pos = this.lineStart = 0;
    this.curLine = 1;
  }
  this.type = types$1.eof;
  this.value = null;
  this.start = this.end = this.pos;
  this.startLoc = this.endLoc = this.curPosition();
  this.lastTokEndLoc = this.lastTokStartLoc = null;
  this.lastTokStart = this.lastTokEnd = this.pos;
  this.context = this.initialContext();
  this.exprAllowed = true;
  this.inModule = options.sourceType === "module";
  this.strict = this.inModule || this.strictDirective(this.pos);
  this.potentialArrowAt = -1;
  this.potentialArrowInForAwait = false;
  this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
  this.labels = [];
  this.undefinedExports = /* @__PURE__ */ Object.create(null);
  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!") {
    this.skipLineComment(2);
  }
  this.scopeStack = [];
  this.enterScope(SCOPE_TOP);
  this.regexpState = null;
  this.privateNameStack = [];
};
var prototypeAccessors = { inFunction: { configurable: true }, inGenerator: { configurable: true }, inAsync: { configurable: true }, canAwait: { configurable: true }, allowSuper: { configurable: true }, allowDirectSuper: { configurable: true }, treatFunctionsAsVar: { configurable: true }, allowNewDotTarget: { configurable: true }, inClassStaticBlock: { configurable: true } };
Parser.prototype.parse = function parse() {
  var node2 = this.options.program || this.startNode();
  this.nextToken();
  return this.parseTopLevel(node2);
};
prototypeAccessors.inFunction.get = function() {
  return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0;
};
prototypeAccessors.inGenerator.get = function() {
  return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 && !this.currentVarScope().inClassFieldInit;
};
prototypeAccessors.inAsync.get = function() {
  return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 && !this.currentVarScope().inClassFieldInit;
};
prototypeAccessors.canAwait.get = function() {
  for (var i = this.scopeStack.length - 1; i >= 0; i--) {
    var scope = this.scopeStack[i];
    if (scope.inClassFieldInit || scope.flags & SCOPE_CLASS_STATIC_BLOCK) {
      return false;
    }
    if (scope.flags & SCOPE_FUNCTION) {
      return (scope.flags & SCOPE_ASYNC) > 0;
    }
  }
  return this.inModule && this.options.ecmaVersion >= 13 || this.options.allowAwaitOutsideFunction;
};
prototypeAccessors.allowSuper.get = function() {
  var ref3 = this.currentThisScope();
  var flags = ref3.flags;
  var inClassFieldInit = ref3.inClassFieldInit;
  return (flags & SCOPE_SUPER) > 0 || inClassFieldInit || this.options.allowSuperOutsideMethod;
};
prototypeAccessors.allowDirectSuper.get = function() {
  return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0;
};
prototypeAccessors.treatFunctionsAsVar.get = function() {
  return this.treatFunctionsAsVarInScope(this.currentScope());
};
prototypeAccessors.allowNewDotTarget.get = function() {
  var ref3 = this.currentThisScope();
  var flags = ref3.flags;
  var inClassFieldInit = ref3.inClassFieldInit;
  return (flags & (SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK)) > 0 || inClassFieldInit;
};
prototypeAccessors.inClassStaticBlock.get = function() {
  return (this.currentVarScope().flags & SCOPE_CLASS_STATIC_BLOCK) > 0;
};
Parser.extend = function extend2() {
  var plugins = [], len = arguments.length;
  while (len--)
    plugins[len] = arguments[len];
  var cls = this;
  for (var i = 0; i < plugins.length; i++) {
    cls = plugins[i](cls);
  }
  return cls;
};
Parser.parse = function parse2(input, options) {
  return new this(options, input).parse();
};
Parser.parseExpressionAt = function parseExpressionAt(input, pos2, options) {
  var parser = new this(options, input, pos2);
  parser.nextToken();
  return parser.parseExpression();
};
Parser.tokenizer = function tokenizer(input, options) {
  return new this(options, input);
};
Object.defineProperties(Parser.prototype, prototypeAccessors);
var pp$9 = Parser.prototype;
var literal = /^(?:'((?:\\.|[^'\\])*?)'|"((?:\\.|[^"\\])*?)")/;
pp$9.strictDirective = function(start3) {
  if (this.options.ecmaVersion < 5) {
    return false;
  }
  for (; ; ) {
    skipWhiteSpace.lastIndex = start3;
    start3 += skipWhiteSpace.exec(this.input)[0].length;
    var match = literal.exec(this.input.slice(start3));
    if (!match) {
      return false;
    }
    if ((match[1] || match[2]) === "use strict") {
      skipWhiteSpace.lastIndex = start3 + match[0].length;
      var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;
      var next = this.input.charAt(end);
      return next === ";" || next === "}" || lineBreak.test(spaceAfter[0]) && !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "=");
    }
    start3 += match[0].length;
    skipWhiteSpace.lastIndex = start3;
    start3 += skipWhiteSpace.exec(this.input)[0].length;
    if (this.input[start3] === ";") {
      start3++;
    }
  }
};
pp$9.eat = function(type) {
  if (this.type === type) {
    this.next();
    return true;
  } else {
    return false;
  }
};
pp$9.isContextual = function(name2) {
  return this.type === types$1.name && this.value === name2 && !this.containsEsc;
};
pp$9.eatContextual = function(name2) {
  if (!this.isContextual(name2)) {
    return false;
  }
  this.next();
  return true;
};
pp$9.expectContextual = function(name2) {
  if (!this.eatContextual(name2)) {
    this.unexpected();
  }
};
pp$9.canInsertSemicolon = function() {
  return this.type === types$1.eof || this.type === types$1.braceR || lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
};
pp$9.insertSemicolon = function() {
  if (this.canInsertSemicolon()) {
    if (this.options.onInsertedSemicolon) {
      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc);
    }
    return true;
  }
};
pp$9.semicolon = function() {
  if (!this.eat(types$1.semi) && !this.insertSemicolon()) {
    this.unexpected();
  }
};
pp$9.afterTrailingComma = function(tokType, notNext) {
  if (this.type === tokType) {
    if (this.options.onTrailingComma) {
      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
    }
    if (!notNext) {
      this.next();
    }
    return true;
  }
};
pp$9.expect = function(type) {
  this.eat(type) || this.unexpected();
};
pp$9.unexpected = function(pos2) {
  this.raise(pos2 != null ? pos2 : this.start, "Unexpected token");
};
var DestructuringErrors = function DestructuringErrors2() {
  this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = this.doubleProto = -1;
};
pp$9.checkPatternErrors = function(refDestructuringErrors, isAssign) {
  if (!refDestructuringErrors) {
    return;
  }
  if (refDestructuringErrors.trailingComma > -1) {
    this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element");
  }
  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
  if (parens > -1) {
    this.raiseRecoverable(parens, isAssign ? "Assigning to rvalue" : "Parenthesized pattern");
  }
};
pp$9.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
  if (!refDestructuringErrors) {
    return false;
  }
  var shorthandAssign = refDestructuringErrors.shorthandAssign;
  var doubleProto = refDestructuringErrors.doubleProto;
  if (!andThrow) {
    return shorthandAssign >= 0 || doubleProto >= 0;
  }
  if (shorthandAssign >= 0) {
    this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns");
  }
  if (doubleProto >= 0) {
    this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property");
  }
};
pp$9.checkYieldAwaitInDefaultParams = function() {
  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos)) {
    this.raise(this.yieldPos, "Yield expression cannot be a default value");
  }
  if (this.awaitPos) {
    this.raise(this.awaitPos, "Await expression cannot be a default value");
  }
};
pp$9.isSimpleAssignTarget = function(expr) {
  if (expr.type === "ParenthesizedExpression") {
    return this.isSimpleAssignTarget(expr.expression);
  }
  return expr.type === "Identifier" || expr.type === "MemberExpression";
};
var pp$8 = Parser.prototype;
pp$8.parseTopLevel = function(node2) {
  var exports = /* @__PURE__ */ Object.create(null);
  if (!node2.body) {
    node2.body = [];
  }
  while (this.type !== types$1.eof) {
    var stmt = this.parseStatement(null, true, exports);
    node2.body.push(stmt);
  }
  if (this.inModule) {
    for (var i = 0, list3 = Object.keys(this.undefinedExports); i < list3.length; i += 1) {
      var name2 = list3[i];
      this.raiseRecoverable(this.undefinedExports[name2].start, "Export '" + name2 + "' is not defined");
    }
  }
  this.adaptDirectivePrologue(node2.body);
  this.next();
  node2.sourceType = this.options.sourceType;
  return this.finishNode(node2, "Program");
};
var loopLabel = { kind: "loop" };
var switchLabel = { kind: "switch" };
pp$8.isLet = function(context) {
  if (this.options.ecmaVersion < 6 || !this.isContextual("let")) {
    return false;
  }
  skipWhiteSpace.lastIndex = this.pos;
  var skip = skipWhiteSpace.exec(this.input);
  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
  if (nextCh === 91 || nextCh === 92) {
    return true;
  }
  if (context) {
    return false;
  }
  if (nextCh === 123 || nextCh > 55295 && nextCh < 56320) {
    return true;
  }
  if (isIdentifierStart(nextCh, true)) {
    var pos2 = next + 1;
    while (isIdentifierChar(nextCh = this.input.charCodeAt(pos2), true)) {
      ++pos2;
    }
    if (nextCh === 92 || nextCh > 55295 && nextCh < 56320) {
      return true;
    }
    var ident = this.input.slice(next, pos2);
    if (!keywordRelationalOperator.test(ident)) {
      return true;
    }
  }
  return false;
};
pp$8.isAsyncFunction = function() {
  if (this.options.ecmaVersion < 8 || !this.isContextual("async")) {
    return false;
  }
  skipWhiteSpace.lastIndex = this.pos;
  var skip = skipWhiteSpace.exec(this.input);
  var next = this.pos + skip[0].length, after;
  return !lineBreak.test(this.input.slice(this.pos, next)) && this.input.slice(next, next + 8) === "function" && (next + 8 === this.input.length || !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 55295 && after < 56320));
};
pp$8.parseStatement = function(context, topLevel, exports) {
  var starttype = this.type, node2 = this.startNode(), kind;
  if (this.isLet(context)) {
    starttype = types$1._var;
    kind = "let";
  }
  switch (starttype) {
    case types$1._break:
    case types$1._continue:
      return this.parseBreakContinueStatement(node2, starttype.keyword);
    case types$1._debugger:
      return this.parseDebuggerStatement(node2);
    case types$1._do:
      return this.parseDoStatement(node2);
    case types$1._for:
      return this.parseForStatement(node2);
    case types$1._function:
      if (context && (this.strict || context !== "if" && context !== "label") && this.options.ecmaVersion >= 6) {
        this.unexpected();
      }
      return this.parseFunctionStatement(node2, false, !context);
    case types$1._class:
      if (context) {
        this.unexpected();
      }
      return this.parseClass(node2, true);
    case types$1._if:
      return this.parseIfStatement(node2);
    case types$1._return:
      return this.parseReturnStatement(node2);
    case types$1._switch:
      return this.parseSwitchStatement(node2);
    case types$1._throw:
      return this.parseThrowStatement(node2);
    case types$1._try:
      return this.parseTryStatement(node2);
    case types$1._const:
    case types$1._var:
      kind = kind || this.value;
      if (context && kind !== "var") {
        this.unexpected();
      }
      return this.parseVarStatement(node2, kind);
    case types$1._while:
      return this.parseWhileStatement(node2);
    case types$1._with:
      return this.parseWithStatement(node2);
    case types$1.braceL:
      return this.parseBlock(true, node2);
    case types$1.semi:
      return this.parseEmptyStatement(node2);
    case types$1._export:
    case types$1._import:
      if (this.options.ecmaVersion > 10 && starttype === types$1._import) {
        skipWhiteSpace.lastIndex = this.pos;
        var skip = skipWhiteSpace.exec(this.input);
        var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
        if (nextCh === 40 || nextCh === 46) {
          return this.parseExpressionStatement(node2, this.parseExpression());
        }
      }
      if (!this.options.allowImportExportEverywhere) {
        if (!topLevel) {
          this.raise(this.start, "'import' and 'export' may only appear at the top level");
        }
        if (!this.inModule) {
          this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
        }
      }
      return starttype === types$1._import ? this.parseImport(node2) : this.parseExport(node2, exports);
    default:
      if (this.isAsyncFunction()) {
        if (context) {
          this.unexpected();
        }
        this.next();
        return this.parseFunctionStatement(node2, true, !context);
      }
      var maybeName = this.value, expr = this.parseExpression();
      if (starttype === types$1.name && expr.type === "Identifier" && this.eat(types$1.colon)) {
        return this.parseLabeledStatement(node2, maybeName, expr, context);
      } else {
        return this.parseExpressionStatement(node2, expr);
      }
  }
};
pp$8.parseBreakContinueStatement = function(node2, keyword) {
  var isBreak = keyword === "break";
  this.next();
  if (this.eat(types$1.semi) || this.insertSemicolon()) {
    node2.label = null;
  } else if (this.type !== types$1.name) {
    this.unexpected();
  } else {
    node2.label = this.parseIdent();
    this.semicolon();
  }
  var i = 0;
  for (; i < this.labels.length; ++i) {
    var lab = this.labels[i];
    if (node2.label == null || lab.name === node2.label.name) {
      if (lab.kind != null && (isBreak || lab.kind === "loop")) {
        break;
      }
      if (node2.label && isBreak) {
        break;
      }
    }
  }
  if (i === this.labels.length) {
    this.raise(node2.start, "Unsyntactic " + keyword);
  }
  return this.finishNode(node2, isBreak ? "BreakStatement" : "ContinueStatement");
};
pp$8.parseDebuggerStatement = function(node2) {
  this.next();
  this.semicolon();
  return this.finishNode(node2, "DebuggerStatement");
};
pp$8.parseDoStatement = function(node2) {
  this.next();
  this.labels.push(loopLabel);
  node2.body = this.parseStatement("do");
  this.labels.pop();
  this.expect(types$1._while);
  node2.test = this.parseParenExpression();
  if (this.options.ecmaVersion >= 6) {
    this.eat(types$1.semi);
  } else {
    this.semicolon();
  }
  return this.finishNode(node2, "DoWhileStatement");
};
pp$8.parseForStatement = function(node2) {
  this.next();
  var awaitAt = this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await") ? this.lastTokStart : -1;
  this.labels.push(loopLabel);
  this.enterScope(0);
  this.expect(types$1.parenL);
  if (this.type === types$1.semi) {
    if (awaitAt > -1) {
      this.unexpected(awaitAt);
    }
    return this.parseFor(node2, null);
  }
  var isLet = this.isLet();
  if (this.type === types$1._var || this.type === types$1._const || isLet) {
    var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
    this.next();
    this.parseVar(init$1, true, kind);
    this.finishNode(init$1, "VariableDeclaration");
    if ((this.type === types$1._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && init$1.declarations.length === 1) {
      if (this.options.ecmaVersion >= 9) {
        if (this.type === types$1._in) {
          if (awaitAt > -1) {
            this.unexpected(awaitAt);
          }
        } else {
          node2.await = awaitAt > -1;
        }
      }
      return this.parseForIn(node2, init$1);
    }
    if (awaitAt > -1) {
      this.unexpected(awaitAt);
    }
    return this.parseFor(node2, init$1);
  }
  var startsWithLet = this.isContextual("let"), isForOf = false;
  var refDestructuringErrors = new DestructuringErrors();
  var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
  if (this.type === types$1._in || (isForOf = this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
    if (this.options.ecmaVersion >= 9) {
      if (this.type === types$1._in) {
        if (awaitAt > -1) {
          this.unexpected(awaitAt);
        }
      } else {
        node2.await = awaitAt > -1;
      }
    }
    if (startsWithLet && isForOf) {
      this.raise(init.start, "The left-hand side of a for-of loop may not start with 'let'.");
    }
    this.toAssignable(init, false, refDestructuringErrors);
    this.checkLValPattern(init);
    return this.parseForIn(node2, init);
  } else {
    this.checkExpressionErrors(refDestructuringErrors, true);
  }
  if (awaitAt > -1) {
    this.unexpected(awaitAt);
  }
  return this.parseFor(node2, init);
};
pp$8.parseFunctionStatement = function(node2, isAsync, declarationPosition) {
  this.next();
  return this.parseFunction(node2, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync);
};
pp$8.parseIfStatement = function(node2) {
  this.next();
  node2.test = this.parseParenExpression();
  node2.consequent = this.parseStatement("if");
  node2.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
  return this.finishNode(node2, "IfStatement");
};
pp$8.parseReturnStatement = function(node2) {
  if (!this.inFunction && !this.options.allowReturnOutsideFunction) {
    this.raise(this.start, "'return' outside of function");
  }
  this.next();
  if (this.eat(types$1.semi) || this.insertSemicolon()) {
    node2.argument = null;
  } else {
    node2.argument = this.parseExpression();
    this.semicolon();
  }
  return this.finishNode(node2, "ReturnStatement");
};
pp$8.parseSwitchStatement = function(node2) {
  this.next();
  node2.discriminant = this.parseParenExpression();
  node2.cases = [];
  this.expect(types$1.braceL);
  this.labels.push(switchLabel);
  this.enterScope(0);
  var cur;
  for (var sawDefault = false; this.type !== types$1.braceR; ) {
    if (this.type === types$1._case || this.type === types$1._default) {
      var isCase = this.type === types$1._case;
      if (cur) {
        this.finishNode(cur, "SwitchCase");
      }
      node2.cases.push(cur = this.startNode());
      cur.consequent = [];
      this.next();
      if (isCase) {
        cur.test = this.parseExpression();
      } else {
        if (sawDefault) {
          this.raiseRecoverable(this.lastTokStart, "Multiple default clauses");
        }
        sawDefault = true;
        cur.test = null;
      }
      this.expect(types$1.colon);
    } else {
      if (!cur) {
        this.unexpected();
      }
      cur.consequent.push(this.parseStatement(null));
    }
  }
  this.exitScope();
  if (cur) {
    this.finishNode(cur, "SwitchCase");
  }
  this.next();
  this.labels.pop();
  return this.finishNode(node2, "SwitchStatement");
};
pp$8.parseThrowStatement = function(node2) {
  this.next();
  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) {
    this.raise(this.lastTokEnd, "Illegal newline after throw");
  }
  node2.argument = this.parseExpression();
  this.semicolon();
  return this.finishNode(node2, "ThrowStatement");
};
var empty$1 = [];
pp$8.parseTryStatement = function(node2) {
  this.next();
  node2.block = this.parseBlock();
  node2.handler = null;
  if (this.type === types$1._catch) {
    var clause = this.startNode();
    this.next();
    if (this.eat(types$1.parenL)) {
      clause.param = this.parseBindingAtom();
      var simple = clause.param.type === "Identifier";
      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
      this.checkLValPattern(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
      this.expect(types$1.parenR);
    } else {
      if (this.options.ecmaVersion < 10) {
        this.unexpected();
      }
      clause.param = null;
      this.enterScope(0);
    }
    clause.body = this.parseBlock(false);
    this.exitScope();
    node2.handler = this.finishNode(clause, "CatchClause");
  }
  node2.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null;
  if (!node2.handler && !node2.finalizer) {
    this.raise(node2.start, "Missing catch or finally clause");
  }
  return this.finishNode(node2, "TryStatement");
};
pp$8.parseVarStatement = function(node2, kind) {
  this.next();
  this.parseVar(node2, false, kind);
  this.semicolon();
  return this.finishNode(node2, "VariableDeclaration");
};
pp$8.parseWhileStatement = function(node2) {
  this.next();
  node2.test = this.parseParenExpression();
  this.labels.push(loopLabel);
  node2.body = this.parseStatement("while");
  this.labels.pop();
  return this.finishNode(node2, "WhileStatement");
};
pp$8.parseWithStatement = function(node2) {
  if (this.strict) {
    this.raise(this.start, "'with' in strict mode");
  }
  this.next();
  node2.object = this.parseParenExpression();
  node2.body = this.parseStatement("with");
  return this.finishNode(node2, "WithStatement");
};
pp$8.parseEmptyStatement = function(node2) {
  this.next();
  return this.finishNode(node2, "EmptyStatement");
};
pp$8.parseLabeledStatement = function(node2, maybeName, expr, context) {
  for (var i$1 = 0, list3 = this.labels; i$1 < list3.length; i$1 += 1) {
    var label = list3[i$1];
    if (label.name === maybeName) {
      this.raise(expr.start, "Label '" + maybeName + "' is already declared");
    }
  }
  var kind = this.type.isLoop ? "loop" : this.type === types$1._switch ? "switch" : null;
  for (var i = this.labels.length - 1; i >= 0; i--) {
    var label$1 = this.labels[i];
    if (label$1.statementStart === node2.start) {
      label$1.statementStart = this.start;
      label$1.kind = kind;
    } else {
      break;
    }
  }
  this.labels.push({ name: maybeName, kind, statementStart: this.start });
  node2.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
  this.labels.pop();
  node2.label = expr;
  return this.finishNode(node2, "LabeledStatement");
};
pp$8.parseExpressionStatement = function(node2, expr) {
  node2.expression = expr;
  this.semicolon();
  return this.finishNode(node2, "ExpressionStatement");
};
pp$8.parseBlock = function(createNewLexicalScope, node2, exitStrict) {
  if (createNewLexicalScope === void 0)
    createNewLexicalScope = true;
  if (node2 === void 0)
    node2 = this.startNode();
  node2.body = [];
  this.expect(types$1.braceL);
  if (createNewLexicalScope) {
    this.enterScope(0);
  }
  while (this.type !== types$1.braceR) {
    var stmt = this.parseStatement(null);
    node2.body.push(stmt);
  }
  if (exitStrict) {
    this.strict = false;
  }
  this.next();
  if (createNewLexicalScope) {
    this.exitScope();
  }
  return this.finishNode(node2, "BlockStatement");
};
pp$8.parseFor = function(node2, init) {
  node2.init = init;
  this.expect(types$1.semi);
  node2.test = this.type === types$1.semi ? null : this.parseExpression();
  this.expect(types$1.semi);
  node2.update = this.type === types$1.parenR ? null : this.parseExpression();
  this.expect(types$1.parenR);
  node2.body = this.parseStatement("for");
  this.exitScope();
  this.labels.pop();
  return this.finishNode(node2, "ForStatement");
};
pp$8.parseForIn = function(node2, init) {
  var isForIn = this.type === types$1._in;
  this.next();
  if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.options.ecmaVersion < 8 || this.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
    this.raise(
      init.start,
      (isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer"
    );
  }
  node2.left = init;
  node2.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
  this.expect(types$1.parenR);
  node2.body = this.parseStatement("for");
  this.exitScope();
  this.labels.pop();
  return this.finishNode(node2, isForIn ? "ForInStatement" : "ForOfStatement");
};
pp$8.parseVar = function(node2, isFor, kind) {
  node2.declarations = [];
  node2.kind = kind;
  for (; ; ) {
    var decl = this.startNode();
    this.parseVarId(decl, kind);
    if (this.eat(types$1.eq)) {
      decl.init = this.parseMaybeAssign(isFor);
    } else if (kind === "const" && !(this.type === types$1._in || this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
      this.unexpected();
    } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types$1._in || this.isContextual("of")))) {
      this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
    } else {
      decl.init = null;
    }
    node2.declarations.push(this.finishNode(decl, "VariableDeclarator"));
    if (!this.eat(types$1.comma)) {
      break;
    }
  }
  return node2;
};
pp$8.parseVarId = function(decl, kind) {
  decl.id = this.parseBindingAtom();
  this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
};
var FUNC_STATEMENT = 1;
var FUNC_HANGING_STATEMENT = 2;
var FUNC_NULLABLE_ID = 4;
pp$8.parseFunction = function(node2, statement, allowExpressionBody, isAsync, forInit) {
  this.initFunction(node2);
  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
    if (this.type === types$1.star && statement & FUNC_HANGING_STATEMENT) {
      this.unexpected();
    }
    node2.generator = this.eat(types$1.star);
  }
  if (this.options.ecmaVersion >= 8) {
    node2.async = !!isAsync;
  }
  if (statement & FUNC_STATEMENT) {
    node2.id = statement & FUNC_NULLABLE_ID && this.type !== types$1.name ? null : this.parseIdent();
    if (node2.id && !(statement & FUNC_HANGING_STATEMENT)) {
      this.checkLValSimple(node2.id, this.strict || node2.generator || node2.async ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION);
    }
  }
  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
  this.yieldPos = 0;
  this.awaitPos = 0;
  this.awaitIdentPos = 0;
  this.enterScope(functionFlags(node2.async, node2.generator));
  if (!(statement & FUNC_STATEMENT)) {
    node2.id = this.type === types$1.name ? this.parseIdent() : null;
  }
  this.parseFunctionParams(node2);
  this.parseFunctionBody(node2, allowExpressionBody, false, forInit);
  this.yieldPos = oldYieldPos;
  this.awaitPos = oldAwaitPos;
  this.awaitIdentPos = oldAwaitIdentPos;
  return this.finishNode(node2, statement & FUNC_STATEMENT ? "FunctionDeclaration" : "FunctionExpression");
};
pp$8.parseFunctionParams = function(node2) {
  this.expect(types$1.parenL);
  node2.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
  this.checkYieldAwaitInDefaultParams();
};
pp$8.parseClass = function(node2, isStatement) {
  this.next();
  var oldStrict = this.strict;
  this.strict = true;
  this.parseClassId(node2, isStatement);
  this.parseClassSuper(node2);
  var privateNameMap = this.enterClassBody();
  var classBody = this.startNode();
  var hadConstructor = false;
  classBody.body = [];
  this.expect(types$1.braceL);
  while (this.type !== types$1.braceR) {
    var element2 = this.parseClassElement(node2.superClass !== null);
    if (element2) {
      classBody.body.push(element2);
      if (element2.type === "MethodDefinition" && element2.kind === "constructor") {
        if (hadConstructor) {
          this.raise(element2.start, "Duplicate constructor in the same class");
        }
        hadConstructor = true;
      } else if (element2.key && element2.key.type === "PrivateIdentifier" && isPrivateNameConflicted(privateNameMap, element2)) {
        this.raiseRecoverable(element2.key.start, "Identifier '#" + element2.key.name + "' has already been declared");
      }
    }
  }
  this.strict = oldStrict;
  this.next();
  node2.body = this.finishNode(classBody, "ClassBody");
  this.exitClassBody();
  return this.finishNode(node2, isStatement ? "ClassDeclaration" : "ClassExpression");
};
pp$8.parseClassElement = function(constructorAllowsSuper) {
  if (this.eat(types$1.semi)) {
    return null;
  }
  var ecmaVersion = this.options.ecmaVersion;
  var node2 = this.startNode();
  var keyName = "";
  var isGenerator = false;
  var isAsync = false;
  var kind = "method";
  var isStatic = false;
  if (this.eatContextual("static")) {
    if (ecmaVersion >= 13 && this.eat(types$1.braceL)) {
      this.parseClassStaticBlock(node2);
      return node2;
    }
    if (this.isClassElementNameStart() || this.type === types$1.star) {
      isStatic = true;
    } else {
      keyName = "static";
    }
  }
  node2.static = isStatic;
  if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
    if ((this.isClassElementNameStart() || this.type === types$1.star) && !this.canInsertSemicolon()) {
      isAsync = true;
    } else {
      keyName = "async";
    }
  }
  if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types$1.star)) {
    isGenerator = true;
  }
  if (!keyName && !isAsync && !isGenerator) {
    var lastValue = this.value;
    if (this.eatContextual("get") || this.eatContextual("set")) {
      if (this.isClassElementNameStart()) {
        kind = lastValue;
      } else {
        keyName = lastValue;
      }
    }
  }
  if (keyName) {
    node2.computed = false;
    node2.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
    node2.key.name = keyName;
    this.finishNode(node2.key, "Identifier");
  } else {
    this.parseClassElementName(node2);
  }
  if (ecmaVersion < 13 || this.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) {
    var isConstructor = !node2.static && checkKeyName(node2, "constructor");
    var allowsDirectSuper = isConstructor && constructorAllowsSuper;
    if (isConstructor && kind !== "method") {
      this.raise(node2.key.start, "Constructor can't have get/set modifier");
    }
    node2.kind = isConstructor ? "constructor" : kind;
    this.parseClassMethod(node2, isGenerator, isAsync, allowsDirectSuper);
  } else {
    this.parseClassField(node2);
  }
  return node2;
};
pp$8.isClassElementNameStart = function() {
  return this.type === types$1.name || this.type === types$1.privateId || this.type === types$1.num || this.type === types$1.string || this.type === types$1.bracketL || this.type.keyword;
};
pp$8.parseClassElementName = function(element2) {
  if (this.type === types$1.privateId) {
    if (this.value === "constructor") {
      this.raise(this.start, "Classes can't have an element named '#constructor'");
    }
    element2.computed = false;
    element2.key = this.parsePrivateIdent();
  } else {
    this.parsePropertyName(element2);
  }
};
pp$8.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
  var key2 = method.key;
  if (method.kind === "constructor") {
    if (isGenerator) {
      this.raise(key2.start, "Constructor can't be a generator");
    }
    if (isAsync) {
      this.raise(key2.start, "Constructor can't be an async method");
    }
  } else if (method.static && checkKeyName(method, "prototype")) {
    this.raise(key2.start, "Classes may not have a static property named prototype");
  }
  var value2 = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
  if (method.kind === "get" && value2.params.length !== 0) {
    this.raiseRecoverable(value2.start, "getter should have no params");
  }
  if (method.kind === "set" && value2.params.length !== 1) {
    this.raiseRecoverable(value2.start, "setter should have exactly one param");
  }
  if (method.kind === "set" && value2.params[0].type === "RestElement") {
    this.raiseRecoverable(value2.params[0].start, "Setter cannot use rest params");
  }
  return this.finishNode(method, "MethodDefinition");
};
pp$8.parseClassField = function(field) {
  if (checkKeyName(field, "constructor")) {
    this.raise(field.key.start, "Classes can't have a field named 'constructor'");
  } else if (field.static && checkKeyName(field, "prototype")) {
    this.raise(field.key.start, "Classes can't have a static field named 'prototype'");
  }
  if (this.eat(types$1.eq)) {
    var scope = this.currentThisScope();
    var inClassFieldInit = scope.inClassFieldInit;
    scope.inClassFieldInit = true;
    field.value = this.parseMaybeAssign();
    scope.inClassFieldInit = inClassFieldInit;
  } else {
    field.value = null;
  }
  this.semicolon();
  return this.finishNode(field, "PropertyDefinition");
};
pp$8.parseClassStaticBlock = function(node2) {
  node2.body = [];
  var oldLabels = this.labels;
  this.labels = [];
  this.enterScope(SCOPE_CLASS_STATIC_BLOCK | SCOPE_SUPER);
  while (this.type !== types$1.braceR) {
    var stmt = this.parseStatement(null);
    node2.body.push(stmt);
  }
  this.next();
  this.exitScope();
  this.labels = oldLabels;
  return this.finishNode(node2, "StaticBlock");
};
pp$8.parseClassId = function(node2, isStatement) {
  if (this.type === types$1.name) {
    node2.id = this.parseIdent();
    if (isStatement) {
      this.checkLValSimple(node2.id, BIND_LEXICAL, false);
    }
  } else {
    if (isStatement === true) {
      this.unexpected();
    }
    node2.id = null;
  }
};
pp$8.parseClassSuper = function(node2) {
  node2.superClass = this.eat(types$1._extends) ? this.parseExprSubscripts(null, false) : null;
};
pp$8.enterClassBody = function() {
  var element2 = { declared: /* @__PURE__ */ Object.create(null), used: [] };
  this.privateNameStack.push(element2);
  return element2.declared;
};
pp$8.exitClassBody = function() {
  var ref3 = this.privateNameStack.pop();
  var declared = ref3.declared;
  var used = ref3.used;
  var len = this.privateNameStack.length;
  var parent = len === 0 ? null : this.privateNameStack[len - 1];
  for (var i = 0; i < used.length; ++i) {
    var id = used[i];
    if (!hasOwn(declared, id.name)) {
      if (parent) {
        parent.used.push(id);
      } else {
        this.raiseRecoverable(id.start, "Private field '#" + id.name + "' must be declared in an enclosing class");
      }
    }
  }
};
function isPrivateNameConflicted(privateNameMap, element2) {
  var name2 = element2.key.name;
  var curr = privateNameMap[name2];
  var next = "true";
  if (element2.type === "MethodDefinition" && (element2.kind === "get" || element2.kind === "set")) {
    next = (element2.static ? "s" : "i") + element2.kind;
  }
  if (curr === "iget" && next === "iset" || curr === "iset" && next === "iget" || curr === "sget" && next === "sset" || curr === "sset" && next === "sget") {
    privateNameMap[name2] = "true";
    return false;
  } else if (!curr) {
    privateNameMap[name2] = next;
    return false;
  } else {
    return true;
  }
}
function checkKeyName(node2, name2) {
  var computed = node2.computed;
  var key2 = node2.key;
  return !computed && (key2.type === "Identifier" && key2.name === name2 || key2.type === "Literal" && key2.value === name2);
}
pp$8.parseExport = function(node2, exports) {
  this.next();
  if (this.eat(types$1.star)) {
    if (this.options.ecmaVersion >= 11) {
      if (this.eatContextual("as")) {
        node2.exported = this.parseModuleExportName();
        this.checkExport(exports, node2.exported, this.lastTokStart);
      } else {
        node2.exported = null;
      }
    }
    this.expectContextual("from");
    if (this.type !== types$1.string) {
      this.unexpected();
    }
    node2.source = this.parseExprAtom();
    this.semicolon();
    return this.finishNode(node2, "ExportAllDeclaration");
  }
  if (this.eat(types$1._default)) {
    this.checkExport(exports, "default", this.lastTokStart);
    var isAsync;
    if (this.type === types$1._function || (isAsync = this.isAsyncFunction())) {
      var fNode = this.startNode();
      this.next();
      if (isAsync) {
        this.next();
      }
      node2.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
    } else if (this.type === types$1._class) {
      var cNode = this.startNode();
      node2.declaration = this.parseClass(cNode, "nullableID");
    } else {
      node2.declaration = this.parseMaybeAssign();
      this.semicolon();
    }
    return this.finishNode(node2, "ExportDefaultDeclaration");
  }
  if (this.shouldParseExportStatement()) {
    node2.declaration = this.parseStatement(null);
    if (node2.declaration.type === "VariableDeclaration") {
      this.checkVariableExport(exports, node2.declaration.declarations);
    } else {
      this.checkExport(exports, node2.declaration.id, node2.declaration.id.start);
    }
    node2.specifiers = [];
    node2.source = null;
  } else {
    node2.declaration = null;
    node2.specifiers = this.parseExportSpecifiers(exports);
    if (this.eatContextual("from")) {
      if (this.type !== types$1.string) {
        this.unexpected();
      }
      node2.source = this.parseExprAtom();
    } else {
      for (var i = 0, list3 = node2.specifiers; i < list3.length; i += 1) {
        var spec = list3[i];
        this.checkUnreserved(spec.local);
        this.checkLocalExport(spec.local);
        if (spec.local.type === "Literal") {
          this.raise(spec.local.start, "A string literal cannot be used as an exported binding without `from`.");
        }
      }
      node2.source = null;
    }
    this.semicolon();
  }
  return this.finishNode(node2, "ExportNamedDeclaration");
};
pp$8.checkExport = function(exports, name2, pos2) {
  if (!exports) {
    return;
  }
  if (typeof name2 !== "string") {
    name2 = name2.type === "Identifier" ? name2.name : name2.value;
  }
  if (hasOwn(exports, name2)) {
    this.raiseRecoverable(pos2, "Duplicate export '" + name2 + "'");
  }
  exports[name2] = true;
};
pp$8.checkPatternExport = function(exports, pat) {
  var type = pat.type;
  if (type === "Identifier") {
    this.checkExport(exports, pat, pat.start);
  } else if (type === "ObjectPattern") {
    for (var i = 0, list3 = pat.properties; i < list3.length; i += 1) {
      var prop = list3[i];
      this.checkPatternExport(exports, prop);
    }
  } else if (type === "ArrayPattern") {
    for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
      var elt = list$1[i$1];
      if (elt) {
        this.checkPatternExport(exports, elt);
      }
    }
  } else if (type === "Property") {
    this.checkPatternExport(exports, pat.value);
  } else if (type === "AssignmentPattern") {
    this.checkPatternExport(exports, pat.left);
  } else if (type === "RestElement") {
    this.checkPatternExport(exports, pat.argument);
  } else if (type === "ParenthesizedExpression") {
    this.checkPatternExport(exports, pat.expression);
  }
};
pp$8.checkVariableExport = function(exports, decls) {
  if (!exports) {
    return;
  }
  for (var i = 0, list3 = decls; i < list3.length; i += 1) {
    var decl = list3[i];
    this.checkPatternExport(exports, decl.id);
  }
};
pp$8.shouldParseExportStatement = function() {
  return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
};
pp$8.parseExportSpecifiers = function(exports) {
  var nodes = [], first = true;
  this.expect(types$1.braceL);
  while (!this.eat(types$1.braceR)) {
    if (!first) {
      this.expect(types$1.comma);
      if (this.afterTrailingComma(types$1.braceR)) {
        break;
      }
    } else {
      first = false;
    }
    var node2 = this.startNode();
    node2.local = this.parseModuleExportName();
    node2.exported = this.eatContextual("as") ? this.parseModuleExportName() : node2.local;
    this.checkExport(
      exports,
      node2.exported,
      node2.exported.start
    );
    nodes.push(this.finishNode(node2, "ExportSpecifier"));
  }
  return nodes;
};
pp$8.parseImport = function(node2) {
  this.next();
  if (this.type === types$1.string) {
    node2.specifiers = empty$1;
    node2.source = this.parseExprAtom();
  } else {
    node2.specifiers = this.parseImportSpecifiers();
    this.expectContextual("from");
    node2.source = this.type === types$1.string ? this.parseExprAtom() : this.unexpected();
  }
  this.semicolon();
  return this.finishNode(node2, "ImportDeclaration");
};
pp$8.parseImportSpecifiers = function() {
  var nodes = [], first = true;
  if (this.type === types$1.name) {
    var node2 = this.startNode();
    node2.local = this.parseIdent();
    this.checkLValSimple(node2.local, BIND_LEXICAL);
    nodes.push(this.finishNode(node2, "ImportDefaultSpecifier"));
    if (!this.eat(types$1.comma)) {
      return nodes;
    }
  }
  if (this.type === types$1.star) {
    var node$1 = this.startNode();
    this.next();
    this.expectContextual("as");
    node$1.local = this.parseIdent();
    this.checkLValSimple(node$1.local, BIND_LEXICAL);
    nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
    return nodes;
  }
  this.expect(types$1.braceL);
  while (!this.eat(types$1.braceR)) {
    if (!first) {
      this.expect(types$1.comma);
      if (this.afterTrailingComma(types$1.braceR)) {
        break;
      }
    } else {
      first = false;
    }
    var node$2 = this.startNode();
    node$2.imported = this.parseModuleExportName();
    if (this.eatContextual("as")) {
      node$2.local = this.parseIdent();
    } else {
      this.checkUnreserved(node$2.imported);
      node$2.local = node$2.imported;
    }
    this.checkLValSimple(node$2.local, BIND_LEXICAL);
    nodes.push(this.finishNode(node$2, "ImportSpecifier"));
  }
  return nodes;
};
pp$8.parseModuleExportName = function() {
  if (this.options.ecmaVersion >= 13 && this.type === types$1.string) {
    var stringLiteral2 = this.parseLiteral(this.value);
    if (loneSurrogate.test(stringLiteral2.value)) {
      this.raise(stringLiteral2.start, "An export name cannot include a lone surrogate.");
    }
    return stringLiteral2;
  }
  return this.parseIdent(true);
};
pp$8.adaptDirectivePrologue = function(statements) {
  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
    statements[i].directive = statements[i].expression.raw.slice(1, -1);
  }
};
pp$8.isDirectiveCandidate = function(statement) {
  return this.options.ecmaVersion >= 5 && statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string" && // Reject parenthesized strings.
  (this.input[statement.start] === '"' || this.input[statement.start] === "'");
};
var pp$7 = Parser.prototype;
pp$7.toAssignable = function(node2, isBinding, refDestructuringErrors) {
  if (this.options.ecmaVersion >= 6 && node2) {
    switch (node2.type) {
      case "Identifier":
        if (this.inAsync && node2.name === "await") {
          this.raise(node2.start, "Cannot use 'await' as identifier inside an async function");
        }
        break;
      case "ObjectPattern":
      case "ArrayPattern":
      case "AssignmentPattern":
      case "RestElement":
        break;
      case "ObjectExpression":
        node2.type = "ObjectPattern";
        if (refDestructuringErrors) {
          this.checkPatternErrors(refDestructuringErrors, true);
        }
        for (var i = 0, list3 = node2.properties; i < list3.length; i += 1) {
          var prop = list3[i];
          this.toAssignable(prop, isBinding);
          if (prop.type === "RestElement" && (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")) {
            this.raise(prop.argument.start, "Unexpected token");
          }
        }
        break;
      case "Property":
        if (node2.kind !== "init") {
          this.raise(node2.key.start, "Object pattern can't contain getter or setter");
        }
        this.toAssignable(node2.value, isBinding);
        break;
      case "ArrayExpression":
        node2.type = "ArrayPattern";
        if (refDestructuringErrors) {
          this.checkPatternErrors(refDestructuringErrors, true);
        }
        this.toAssignableList(node2.elements, isBinding);
        break;
      case "SpreadElement":
        node2.type = "RestElement";
        this.toAssignable(node2.argument, isBinding);
        if (node2.argument.type === "AssignmentPattern") {
          this.raise(node2.argument.start, "Rest elements cannot have a default value");
        }
        break;
      case "AssignmentExpression":
        if (node2.operator !== "=") {
          this.raise(node2.left.end, "Only '=' operator can be used for specifying default value.");
        }
        node2.type = "AssignmentPattern";
        delete node2.operator;
        this.toAssignable(node2.left, isBinding);
        break;
      case "ParenthesizedExpression":
        this.toAssignable(node2.expression, isBinding, refDestructuringErrors);
        break;
      case "ChainExpression":
        this.raiseRecoverable(node2.start, "Optional chaining cannot appear in left-hand side");
        break;
      case "MemberExpression":
        if (!isBinding) {
          break;
        }
      default:
        this.raise(node2.start, "Assigning to rvalue");
    }
  } else if (refDestructuringErrors) {
    this.checkPatternErrors(refDestructuringErrors, true);
  }
  return node2;
};
pp$7.toAssignableList = function(exprList, isBinding) {
  var end = exprList.length;
  for (var i = 0; i < end; i++) {
    var elt = exprList[i];
    if (elt) {
      this.toAssignable(elt, isBinding);
    }
  }
  if (end) {
    var last = exprList[end - 1];
    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier") {
      this.unexpected(last.argument.start);
    }
  }
  return exprList;
};
pp$7.parseSpread = function(refDestructuringErrors) {
  var node2 = this.startNode();
  this.next();
  node2.argument = this.parseMaybeAssign(false, refDestructuringErrors);
  return this.finishNode(node2, "SpreadElement");
};
pp$7.parseRestBinding = function() {
  var node2 = this.startNode();
  this.next();
  if (this.options.ecmaVersion === 6 && this.type !== types$1.name) {
    this.unexpected();
  }
  node2.argument = this.parseBindingAtom();
  return this.finishNode(node2, "RestElement");
};
pp$7.parseBindingAtom = function() {
  if (this.options.ecmaVersion >= 6) {
    switch (this.type) {
      case types$1.bracketL:
        var node2 = this.startNode();
        this.next();
        node2.elements = this.parseBindingList(types$1.bracketR, true, true);
        return this.finishNode(node2, "ArrayPattern");
      case types$1.braceL:
        return this.parseObj(true);
    }
  }
  return this.parseIdent();
};
pp$7.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
  var elts = [], first = true;
  while (!this.eat(close)) {
    if (first) {
      first = false;
    } else {
      this.expect(types$1.comma);
    }
    if (allowEmpty && this.type === types$1.comma) {
      elts.push(null);
    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
      break;
    } else if (this.type === types$1.ellipsis) {
      var rest = this.parseRestBinding();
      this.parseBindingListItem(rest);
      elts.push(rest);
      if (this.type === types$1.comma) {
        this.raise(this.start, "Comma is not permitted after the rest element");
      }
      this.expect(close);
      break;
    } else {
      var elem = this.parseMaybeDefault(this.start, this.startLoc);
      this.parseBindingListItem(elem);
      elts.push(elem);
    }
  }
  return elts;
};
pp$7.parseBindingListItem = function(param) {
  return param;
};
pp$7.parseMaybeDefault = function(startPos, startLoc, left) {
  left = left || this.parseBindingAtom();
  if (this.options.ecmaVersion < 6 || !this.eat(types$1.eq)) {
    return left;
  }
  var node2 = this.startNodeAt(startPos, startLoc);
  node2.left = left;
  node2.right = this.parseMaybeAssign();
  return this.finishNode(node2, "AssignmentPattern");
};
pp$7.checkLValSimple = function(expr, bindingType, checkClashes) {
  if (bindingType === void 0)
    bindingType = BIND_NONE;
  var isBind = bindingType !== BIND_NONE;
  switch (expr.type) {
    case "Identifier":
      if (this.strict && this.reservedWordsStrictBind.test(expr.name)) {
        this.raiseRecoverable(expr.start, (isBind ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
      }
      if (isBind) {
        if (bindingType === BIND_LEXICAL && expr.name === "let") {
          this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name");
        }
        if (checkClashes) {
          if (hasOwn(checkClashes, expr.name)) {
            this.raiseRecoverable(expr.start, "Argument name clash");
          }
          checkClashes[expr.name] = true;
        }
        if (bindingType !== BIND_OUTSIDE) {
          this.declareName(expr.name, bindingType, expr.start);
        }
      }
      break;
    case "ChainExpression":
      this.raiseRecoverable(expr.start, "Optional chaining cannot appear in left-hand side");
      break;
    case "MemberExpression":
      if (isBind) {
        this.raiseRecoverable(expr.start, "Binding member expression");
      }
      break;
    case "ParenthesizedExpression":
      if (isBind) {
        this.raiseRecoverable(expr.start, "Binding parenthesized expression");
      }
      return this.checkLValSimple(expr.expression, bindingType, checkClashes);
    default:
      this.raise(expr.start, (isBind ? "Binding" : "Assigning to") + " rvalue");
  }
};
pp$7.checkLValPattern = function(expr, bindingType, checkClashes) {
  if (bindingType === void 0)
    bindingType = BIND_NONE;
  switch (expr.type) {
    case "ObjectPattern":
      for (var i = 0, list3 = expr.properties; i < list3.length; i += 1) {
        var prop = list3[i];
        this.checkLValInnerPattern(prop, bindingType, checkClashes);
      }
      break;
    case "ArrayPattern":
      for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
        var elem = list$1[i$1];
        if (elem) {
          this.checkLValInnerPattern(elem, bindingType, checkClashes);
        }
      }
      break;
    default:
      this.checkLValSimple(expr, bindingType, checkClashes);
  }
};
pp$7.checkLValInnerPattern = function(expr, bindingType, checkClashes) {
  if (bindingType === void 0)
    bindingType = BIND_NONE;
  switch (expr.type) {
    case "Property":
      this.checkLValInnerPattern(expr.value, bindingType, checkClashes);
      break;
    case "AssignmentPattern":
      this.checkLValPattern(expr.left, bindingType, checkClashes);
      break;
    case "RestElement":
      this.checkLValPattern(expr.argument, bindingType, checkClashes);
      break;
    default:
      this.checkLValPattern(expr, bindingType, checkClashes);
  }
};
var TokContext = function TokContext2(token2, isExpr, preserveSpace, override, generator) {
  this.token = token2;
  this.isExpr = !!isExpr;
  this.preserveSpace = !!preserveSpace;
  this.override = override;
  this.generator = !!generator;
};
var types = {
  b_stat: new TokContext("{", false),
  b_expr: new TokContext("{", true),
  b_tmpl: new TokContext("${", false),
  p_stat: new TokContext("(", false),
  p_expr: new TokContext("(", true),
  q_tmpl: new TokContext("`", true, true, function(p) {
    return p.tryReadTemplateToken();
  }),
  f_stat: new TokContext("function", false),
  f_expr: new TokContext("function", true),
  f_expr_gen: new TokContext("function", true, false, null, true),
  f_gen: new TokContext("function", false, false, null, true)
};
var pp$6 = Parser.prototype;
pp$6.initialContext = function() {
  return [types.b_stat];
};
pp$6.curContext = function() {
  return this.context[this.context.length - 1];
};
pp$6.braceIsBlock = function(prevType) {
  var parent = this.curContext();
  if (parent === types.f_expr || parent === types.f_stat) {
    return true;
  }
  if (prevType === types$1.colon && (parent === types.b_stat || parent === types.b_expr)) {
    return !parent.isExpr;
  }
  if (prevType === types$1._return || prevType === types$1.name && this.exprAllowed) {
    return lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
  }
  if (prevType === types$1._else || prevType === types$1.semi || prevType === types$1.eof || prevType === types$1.parenR || prevType === types$1.arrow) {
    return true;
  }
  if (prevType === types$1.braceL) {
    return parent === types.b_stat;
  }
  if (prevType === types$1._var || prevType === types$1._const || prevType === types$1.name) {
    return false;
  }
  return !this.exprAllowed;
};
pp$6.inGeneratorContext = function() {
  for (var i = this.context.length - 1; i >= 1; i--) {
    var context = this.context[i];
    if (context.token === "function") {
      return context.generator;
    }
  }
  return false;
};
pp$6.updateContext = function(prevType) {
  var update, type = this.type;
  if (type.keyword && prevType === types$1.dot) {
    this.exprAllowed = false;
  } else if (update = type.updateContext) {
    update.call(this, prevType);
  } else {
    this.exprAllowed = type.beforeExpr;
  }
};
pp$6.overrideContext = function(tokenCtx) {
  if (this.curContext() !== tokenCtx) {
    this.context[this.context.length - 1] = tokenCtx;
  }
};
types$1.parenR.updateContext = types$1.braceR.updateContext = function() {
  if (this.context.length === 1) {
    this.exprAllowed = true;
    return;
  }
  var out = this.context.pop();
  if (out === types.b_stat && this.curContext().token === "function") {
    out = this.context.pop();
  }
  this.exprAllowed = !out.isExpr;
};
types$1.braceL.updateContext = function(prevType) {
  this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);
  this.exprAllowed = true;
};
types$1.dollarBraceL.updateContext = function() {
  this.context.push(types.b_tmpl);
  this.exprAllowed = true;
};
types$1.parenL.updateContext = function(prevType) {
  var statementParens = prevType === types$1._if || prevType === types$1._for || prevType === types$1._with || prevType === types$1._while;
  this.context.push(statementParens ? types.p_stat : types.p_expr);
  this.exprAllowed = true;
};
types$1.incDec.updateContext = function() {
};
types$1._function.updateContext = types$1._class.updateContext = function(prevType) {
  if (prevType.beforeExpr && prevType !== types$1._else && !(prevType === types$1.semi && this.curContext() !== types.p_stat) && !(prevType === types$1._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) && !((prevType === types$1.colon || prevType === types$1.braceL) && this.curContext() === types.b_stat)) {
    this.context.push(types.f_expr);
  } else {
    this.context.push(types.f_stat);
  }
  this.exprAllowed = false;
};
types$1.backQuote.updateContext = function() {
  if (this.curContext() === types.q_tmpl) {
    this.context.pop();
  } else {
    this.context.push(types.q_tmpl);
  }
  this.exprAllowed = false;
};
types$1.star.updateContext = function(prevType) {
  if (prevType === types$1._function) {
    var index2 = this.context.length - 1;
    if (this.context[index2] === types.f_expr) {
      this.context[index2] = types.f_expr_gen;
    } else {
      this.context[index2] = types.f_gen;
    }
  }
  this.exprAllowed = true;
};
types$1.name.updateContext = function(prevType) {
  var allowed = false;
  if (this.options.ecmaVersion >= 6 && prevType !== types$1.dot) {
    if (this.value === "of" && !this.exprAllowed || this.value === "yield" && this.inGeneratorContext()) {
      allowed = true;
    }
  }
  this.exprAllowed = allowed;
};
var pp$5 = Parser.prototype;
pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
  if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement") {
    return;
  }
  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand)) {
    return;
  }
  var key2 = prop.key;
  var name2;
  switch (key2.type) {
    case "Identifier":
      name2 = key2.name;
      break;
    case "Literal":
      name2 = String(key2.value);
      break;
    default:
      return;
  }
  var kind = prop.kind;
  if (this.options.ecmaVersion >= 6) {
    if (name2 === "__proto__" && kind === "init") {
      if (propHash.proto) {
        if (refDestructuringErrors) {
          if (refDestructuringErrors.doubleProto < 0) {
            refDestructuringErrors.doubleProto = key2.start;
          }
        } else {
          this.raiseRecoverable(key2.start, "Redefinition of __proto__ property");
        }
      }
      propHash.proto = true;
    }
    return;
  }
  name2 = "$" + name2;
  var other = propHash[name2];
  if (other) {
    var redefinition;
    if (kind === "init") {
      redefinition = this.strict && other.init || other.get || other.set;
    } else {
      redefinition = other.init || other[kind];
    }
    if (redefinition) {
      this.raiseRecoverable(key2.start, "Redefinition of property");
    }
  } else {
    other = propHash[name2] = {
      init: false,
      get: false,
      set: false
    };
  }
  other[kind] = true;
};
pp$5.parseExpression = function(forInit, refDestructuringErrors) {
  var startPos = this.start, startLoc = this.startLoc;
  var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
  if (this.type === types$1.comma) {
    var node2 = this.startNodeAt(startPos, startLoc);
    node2.expressions = [expr];
    while (this.eat(types$1.comma)) {
      node2.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors));
    }
    return this.finishNode(node2, "SequenceExpression");
  }
  return expr;
};
pp$5.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
  if (this.isContextual("yield")) {
    if (this.inGenerator) {
      return this.parseYield(forInit);
    } else {
      this.exprAllowed = false;
    }
  }
  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldDoubleProto = -1;
  if (refDestructuringErrors) {
    oldParenAssign = refDestructuringErrors.parenthesizedAssign;
    oldTrailingComma = refDestructuringErrors.trailingComma;
    oldDoubleProto = refDestructuringErrors.doubleProto;
    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
  } else {
    refDestructuringErrors = new DestructuringErrors();
    ownDestructuringErrors = true;
  }
  var startPos = this.start, startLoc = this.startLoc;
  if (this.type === types$1.parenL || this.type === types$1.name) {
    this.potentialArrowAt = this.start;
    this.potentialArrowInForAwait = forInit === "await";
  }
  var left = this.parseMaybeConditional(forInit, refDestructuringErrors);
  if (afterLeftParse) {
    left = afterLeftParse.call(this, left, startPos, startLoc);
  }
  if (this.type.isAssign) {
    var node2 = this.startNodeAt(startPos, startLoc);
    node2.operator = this.value;
    if (this.type === types$1.eq) {
      left = this.toAssignable(left, false, refDestructuringErrors);
    }
    if (!ownDestructuringErrors) {
      refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
    }
    if (refDestructuringErrors.shorthandAssign >= left.start) {
      refDestructuringErrors.shorthandAssign = -1;
    }
    if (this.type === types$1.eq) {
      this.checkLValPattern(left);
    } else {
      this.checkLValSimple(left);
    }
    node2.left = left;
    this.next();
    node2.right = this.parseMaybeAssign(forInit);
    if (oldDoubleProto > -1) {
      refDestructuringErrors.doubleProto = oldDoubleProto;
    }
    return this.finishNode(node2, "AssignmentExpression");
  } else {
    if (ownDestructuringErrors) {
      this.checkExpressionErrors(refDestructuringErrors, true);
    }
  }
  if (oldParenAssign > -1) {
    refDestructuringErrors.parenthesizedAssign = oldParenAssign;
  }
  if (oldTrailingComma > -1) {
    refDestructuringErrors.trailingComma = oldTrailingComma;
  }
  return left;
};
pp$5.parseMaybeConditional = function(forInit, refDestructuringErrors) {
  var startPos = this.start, startLoc = this.startLoc;
  var expr = this.parseExprOps(forInit, refDestructuringErrors);
  if (this.checkExpressionErrors(refDestructuringErrors)) {
    return expr;
  }
  if (this.eat(types$1.question)) {
    var node2 = this.startNodeAt(startPos, startLoc);
    node2.test = expr;
    node2.consequent = this.parseMaybeAssign();
    this.expect(types$1.colon);
    node2.alternate = this.parseMaybeAssign(forInit);
    return this.finishNode(node2, "ConditionalExpression");
  }
  return expr;
};
pp$5.parseExprOps = function(forInit, refDestructuringErrors) {
  var startPos = this.start, startLoc = this.startLoc;
  var expr = this.parseMaybeUnary(refDestructuringErrors, false, false, forInit);
  if (this.checkExpressionErrors(refDestructuringErrors)) {
    return expr;
  }
  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, forInit);
};
pp$5.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
  var prec = this.type.binop;
  if (prec != null && (!forInit || this.type !== types$1._in)) {
    if (prec > minPrec) {
      var logical = this.type === types$1.logicalOR || this.type === types$1.logicalAND;
      var coalesce = this.type === types$1.coalesce;
      if (coalesce) {
        prec = types$1.logicalAND.binop;
      }
      var op = this.value;
      this.next();
      var startPos = this.start, startLoc = this.startLoc;
      var right = this.parseExprOp(this.parseMaybeUnary(null, false, false, forInit), startPos, startLoc, prec, forInit);
      var node2 = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
      if (logical && this.type === types$1.coalesce || coalesce && (this.type === types$1.logicalOR || this.type === types$1.logicalAND)) {
        this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
      }
      return this.parseExprOp(node2, leftStartPos, leftStartLoc, minPrec, forInit);
    }
  }
  return left;
};
pp$5.buildBinary = function(startPos, startLoc, left, right, op, logical) {
  if (right.type === "PrivateIdentifier") {
    this.raise(right.start, "Private identifier can only be left side of binary expression");
  }
  var node2 = this.startNodeAt(startPos, startLoc);
  node2.left = left;
  node2.operator = op;
  node2.right = right;
  return this.finishNode(node2, logical ? "LogicalExpression" : "BinaryExpression");
};
pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forInit) {
  var startPos = this.start, startLoc = this.startLoc, expr;
  if (this.isContextual("await") && this.canAwait) {
    expr = this.parseAwait(forInit);
    sawUnary = true;
  } else if (this.type.prefix) {
    var node2 = this.startNode(), update = this.type === types$1.incDec;
    node2.operator = this.value;
    node2.prefix = true;
    this.next();
    node2.argument = this.parseMaybeUnary(null, true, update, forInit);
    this.checkExpressionErrors(refDestructuringErrors, true);
    if (update) {
      this.checkLValSimple(node2.argument);
    } else if (this.strict && node2.operator === "delete" && node2.argument.type === "Identifier") {
      this.raiseRecoverable(node2.start, "Deleting local variable in strict mode");
    } else if (node2.operator === "delete" && isPrivateFieldAccess(node2.argument)) {
      this.raiseRecoverable(node2.start, "Private fields can not be deleted");
    } else {
      sawUnary = true;
    }
    expr = this.finishNode(node2, update ? "UpdateExpression" : "UnaryExpression");
  } else if (!sawUnary && this.type === types$1.privateId) {
    if (forInit || this.privateNameStack.length === 0) {
      this.unexpected();
    }
    expr = this.parsePrivateIdent();
    if (this.type !== types$1._in) {
      this.unexpected();
    }
  } else {
    expr = this.parseExprSubscripts(refDestructuringErrors, forInit);
    if (this.checkExpressionErrors(refDestructuringErrors)) {
      return expr;
    }
    while (this.type.postfix && !this.canInsertSemicolon()) {
      var node$1 = this.startNodeAt(startPos, startLoc);
      node$1.operator = this.value;
      node$1.prefix = false;
      node$1.argument = expr;
      this.checkLValSimple(expr);
      this.next();
      expr = this.finishNode(node$1, "UpdateExpression");
    }
  }
  if (!incDec && this.eat(types$1.starstar)) {
    if (sawUnary) {
      this.unexpected(this.lastTokStart);
    } else {
      return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false, false, forInit), "**", false);
    }
  } else {
    return expr;
  }
};
function isPrivateFieldAccess(node2) {
  return node2.type === "MemberExpression" && node2.property.type === "PrivateIdentifier" || node2.type === "ChainExpression" && isPrivateFieldAccess(node2.expression);
}
pp$5.parseExprSubscripts = function(refDestructuringErrors, forInit) {
  var startPos = this.start, startLoc = this.startLoc;
  var expr = this.parseExprAtom(refDestructuringErrors, forInit);
  if (expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")") {
    return expr;
  }
  var result = this.parseSubscripts(expr, startPos, startLoc, false, forInit);
  if (refDestructuringErrors && result.type === "MemberExpression") {
    if (refDestructuringErrors.parenthesizedAssign >= result.start) {
      refDestructuringErrors.parenthesizedAssign = -1;
    }
    if (refDestructuringErrors.parenthesizedBind >= result.start) {
      refDestructuringErrors.parenthesizedBind = -1;
    }
    if (refDestructuringErrors.trailingComma >= result.start) {
      refDestructuringErrors.trailingComma = -1;
    }
  }
  return result;
};
pp$5.parseSubscripts = function(base2, startPos, startLoc, noCalls, forInit) {
  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base2.type === "Identifier" && base2.name === "async" && this.lastTokEnd === base2.end && !this.canInsertSemicolon() && base2.end - base2.start === 5 && this.potentialArrowAt === base2.start;
  var optionalChained = false;
  while (true) {
    var element2 = this.parseSubscript(base2, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
    if (element2.optional) {
      optionalChained = true;
    }
    if (element2 === base2 || element2.type === "ArrowFunctionExpression") {
      if (optionalChained) {
        var chainNode = this.startNodeAt(startPos, startLoc);
        chainNode.expression = element2;
        element2 = this.finishNode(chainNode, "ChainExpression");
      }
      return element2;
    }
    base2 = element2;
  }
};
pp$5.parseSubscript = function(base2, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
  var optionalSupported = this.options.ecmaVersion >= 11;
  var optional = optionalSupported && this.eat(types$1.questionDot);
  if (noCalls && optional) {
    this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions");
  }
  var computed = this.eat(types$1.bracketL);
  if (computed || optional && this.type !== types$1.parenL && this.type !== types$1.backQuote || this.eat(types$1.dot)) {
    var node2 = this.startNodeAt(startPos, startLoc);
    node2.object = base2;
    if (computed) {
      node2.property = this.parseExpression();
      this.expect(types$1.bracketR);
    } else if (this.type === types$1.privateId && base2.type !== "Super") {
      node2.property = this.parsePrivateIdent();
    } else {
      node2.property = this.parseIdent(this.options.allowReserved !== "never");
    }
    node2.computed = !!computed;
    if (optionalSupported) {
      node2.optional = optional;
    }
    base2 = this.finishNode(node2, "MemberExpression");
  } else if (!noCalls && this.eat(types$1.parenL)) {
    var refDestructuringErrors = new DestructuringErrors(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
    this.yieldPos = 0;
    this.awaitPos = 0;
    this.awaitIdentPos = 0;
    var exprList = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);
    if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(types$1.arrow)) {
      this.checkPatternErrors(refDestructuringErrors, false);
      this.checkYieldAwaitInDefaultParams();
      if (this.awaitIdentPos > 0) {
        this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function");
      }
      this.yieldPos = oldYieldPos;
      this.awaitPos = oldAwaitPos;
      this.awaitIdentPos = oldAwaitIdentPos;
      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true, forInit);
    }
    this.checkExpressionErrors(refDestructuringErrors, true);
    this.yieldPos = oldYieldPos || this.yieldPos;
    this.awaitPos = oldAwaitPos || this.awaitPos;
    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;
    var node$1 = this.startNodeAt(startPos, startLoc);
    node$1.callee = base2;
    node$1.arguments = exprList;
    if (optionalSupported) {
      node$1.optional = optional;
    }
    base2 = this.finishNode(node$1, "CallExpression");
  } else if (this.type === types$1.backQuote) {
    if (optional || optionalChained) {
      this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
    }
    var node$2 = this.startNodeAt(startPos, startLoc);
    node$2.tag = base2;
    node$2.quasi = this.parseTemplate({ isTagged: true });
    base2 = this.finishNode(node$2, "TaggedTemplateExpression");
  }
  return base2;
};
pp$5.parseExprAtom = function(refDestructuringErrors, forInit) {
  if (this.type === types$1.slash) {
    this.readRegexp();
  }
  var node2, canBeArrow = this.potentialArrowAt === this.start;
  switch (this.type) {
    case types$1._super:
      if (!this.allowSuper) {
        this.raise(this.start, "'super' keyword outside a method");
      }
      node2 = this.startNode();
      this.next();
      if (this.type === types$1.parenL && !this.allowDirectSuper) {
        this.raise(node2.start, "super() call outside constructor of a subclass");
      }
      if (this.type !== types$1.dot && this.type !== types$1.bracketL && this.type !== types$1.parenL) {
        this.unexpected();
      }
      return this.finishNode(node2, "Super");
    case types$1._this:
      node2 = this.startNode();
      this.next();
      return this.finishNode(node2, "ThisExpression");
    case types$1.name:
      var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
      var id = this.parseIdent(false);
      if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types$1._function)) {
        this.overrideContext(types.f_expr);
        return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true, forInit);
      }
      if (canBeArrow && !this.canInsertSemicolon()) {
        if (this.eat(types$1.arrow)) {
          return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false, forInit);
        }
        if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types$1.name && !containsEsc && (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) {
          id = this.parseIdent(false);
          if (this.canInsertSemicolon() || !this.eat(types$1.arrow)) {
            this.unexpected();
          }
          return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true, forInit);
        }
      }
      return id;
    case types$1.regexp:
      var value2 = this.value;
      node2 = this.parseLiteral(value2.value);
      node2.regex = { pattern: value2.pattern, flags: value2.flags };
      return node2;
    case types$1.num:
    case types$1.string:
      return this.parseLiteral(this.value);
    case types$1._null:
    case types$1._true:
    case types$1._false:
      node2 = this.startNode();
      node2.value = this.type === types$1._null ? null : this.type === types$1._true;
      node2.raw = this.type.keyword;
      this.next();
      return this.finishNode(node2, "Literal");
    case types$1.parenL:
      var start3 = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow, forInit);
      if (refDestructuringErrors) {
        if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr)) {
          refDestructuringErrors.parenthesizedAssign = start3;
        }
        if (refDestructuringErrors.parenthesizedBind < 0) {
          refDestructuringErrors.parenthesizedBind = start3;
        }
      }
      return expr;
    case types$1.bracketL:
      node2 = this.startNode();
      this.next();
      node2.elements = this.parseExprList(types$1.bracketR, true, true, refDestructuringErrors);
      return this.finishNode(node2, "ArrayExpression");
    case types$1.braceL:
      this.overrideContext(types.b_expr);
      return this.parseObj(false, refDestructuringErrors);
    case types$1._function:
      node2 = this.startNode();
      this.next();
      return this.parseFunction(node2, 0);
    case types$1._class:
      return this.parseClass(this.startNode(), false);
    case types$1._new:
      return this.parseNew();
    case types$1.backQuote:
      return this.parseTemplate();
    case types$1._import:
      if (this.options.ecmaVersion >= 11) {
        return this.parseExprImport();
      } else {
        return this.unexpected();
      }
    default:
      this.unexpected();
  }
};
pp$5.parseExprImport = function() {
  var node2 = this.startNode();
  if (this.containsEsc) {
    this.raiseRecoverable(this.start, "Escape sequence in keyword import");
  }
  var meta = this.parseIdent(true);
  switch (this.type) {
    case types$1.parenL:
      return this.parseDynamicImport(node2);
    case types$1.dot:
      node2.meta = meta;
      return this.parseImportMeta(node2);
    default:
      this.unexpected();
  }
};
pp$5.parseDynamicImport = function(node2) {
  this.next();
  node2.source = this.parseMaybeAssign();
  if (!this.eat(types$1.parenR)) {
    var errorPos = this.start;
    if (this.eat(types$1.comma) && this.eat(types$1.parenR)) {
      this.raiseRecoverable(errorPos, "Trailing comma is not allowed in import()");
    } else {
      this.unexpected(errorPos);
    }
  }
  return this.finishNode(node2, "ImportExpression");
};
pp$5.parseImportMeta = function(node2) {
  this.next();
  var containsEsc = this.containsEsc;
  node2.property = this.parseIdent(true);
  if (node2.property.name !== "meta") {
    this.raiseRecoverable(node2.property.start, "The only valid meta property for import is 'import.meta'");
  }
  if (containsEsc) {
    this.raiseRecoverable(node2.start, "'import.meta' must not contain escaped characters");
  }
  if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere) {
    this.raiseRecoverable(node2.start, "Cannot use 'import.meta' outside a module");
  }
  return this.finishNode(node2, "MetaProperty");
};
pp$5.parseLiteral = function(value2) {
  var node2 = this.startNode();
  node2.value = value2;
  node2.raw = this.input.slice(this.start, this.end);
  if (node2.raw.charCodeAt(node2.raw.length - 1) === 110) {
    node2.bigint = node2.raw.slice(0, -1).replace(/_/g, "");
  }
  this.next();
  return this.finishNode(node2, "Literal");
};
pp$5.parseParenExpression = function() {
  this.expect(types$1.parenL);
  var val = this.parseExpression();
  this.expect(types$1.parenR);
  return val;
};
pp$5.parseParenAndDistinguishExpression = function(canBeArrow, forInit) {
  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
  if (this.options.ecmaVersion >= 6) {
    this.next();
    var innerStartPos = this.start, innerStartLoc = this.startLoc;
    var exprList = [], first = true, lastIsComma = false;
    var refDestructuringErrors = new DestructuringErrors(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
    this.yieldPos = 0;
    this.awaitPos = 0;
    while (this.type !== types$1.parenR) {
      first ? first = false : this.expect(types$1.comma);
      if (allowTrailingComma && this.afterTrailingComma(types$1.parenR, true)) {
        lastIsComma = true;
        break;
      } else if (this.type === types$1.ellipsis) {
        spreadStart = this.start;
        exprList.push(this.parseParenItem(this.parseRestBinding()));
        if (this.type === types$1.comma) {
          this.raise(this.start, "Comma is not permitted after the rest element");
        }
        break;
      } else {
        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));
      }
    }
    var innerEndPos = this.lastTokEnd, innerEndLoc = this.lastTokEndLoc;
    this.expect(types$1.parenR);
    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types$1.arrow)) {
      this.checkPatternErrors(refDestructuringErrors, false);
      this.checkYieldAwaitInDefaultParams();
      this.yieldPos = oldYieldPos;
      this.awaitPos = oldAwaitPos;
      return this.parseParenArrowList(startPos, startLoc, exprList, forInit);
    }
    if (!exprList.length || lastIsComma) {
      this.unexpected(this.lastTokStart);
    }
    if (spreadStart) {
      this.unexpected(spreadStart);
    }
    this.checkExpressionErrors(refDestructuringErrors, true);
    this.yieldPos = oldYieldPos || this.yieldPos;
    this.awaitPos = oldAwaitPos || this.awaitPos;
    if (exprList.length > 1) {
      val = this.startNodeAt(innerStartPos, innerStartLoc);
      val.expressions = exprList;
      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
    } else {
      val = exprList[0];
    }
  } else {
    val = this.parseParenExpression();
  }
  if (this.options.preserveParens) {
    var par = this.startNodeAt(startPos, startLoc);
    par.expression = val;
    return this.finishNode(par, "ParenthesizedExpression");
  } else {
    return val;
  }
};
pp$5.parseParenItem = function(item) {
  return item;
};
pp$5.parseParenArrowList = function(startPos, startLoc, exprList, forInit) {
  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, false, forInit);
};
var empty = [];
pp$5.parseNew = function() {
  if (this.containsEsc) {
    this.raiseRecoverable(this.start, "Escape sequence in keyword new");
  }
  var node2 = this.startNode();
  var meta = this.parseIdent(true);
  if (this.options.ecmaVersion >= 6 && this.eat(types$1.dot)) {
    node2.meta = meta;
    var containsEsc = this.containsEsc;
    node2.property = this.parseIdent(true);
    if (node2.property.name !== "target") {
      this.raiseRecoverable(node2.property.start, "The only valid meta property for new is 'new.target'");
    }
    if (containsEsc) {
      this.raiseRecoverable(node2.start, "'new.target' must not contain escaped characters");
    }
    if (!this.allowNewDotTarget) {
      this.raiseRecoverable(node2.start, "'new.target' can only be used in functions and class static block");
    }
    return this.finishNode(node2, "MetaProperty");
  }
  var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types$1._import;
  node2.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true, false);
  if (isImport && node2.callee.type === "ImportExpression") {
    this.raise(startPos, "Cannot use new with import()");
  }
  if (this.eat(types$1.parenL)) {
    node2.arguments = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false);
  } else {
    node2.arguments = empty;
  }
  return this.finishNode(node2, "NewExpression");
};
pp$5.parseTemplateElement = function(ref3) {
  var isTagged = ref3.isTagged;
  var elem = this.startNode();
  if (this.type === types$1.invalidTemplate) {
    if (!isTagged) {
      this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
    }
    elem.value = {
      raw: this.value,
      cooked: null
    };
  } else {
    elem.value = {
      raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
      cooked: this.value
    };
  }
  this.next();
  elem.tail = this.type === types$1.backQuote;
  return this.finishNode(elem, "TemplateElement");
};
pp$5.parseTemplate = function(ref3) {
  if (ref3 === void 0)
    ref3 = {};
  var isTagged = ref3.isTagged;
  if (isTagged === void 0)
    isTagged = false;
  var node2 = this.startNode();
  this.next();
  node2.expressions = [];
  var curElt = this.parseTemplateElement({ isTagged });
  node2.quasis = [curElt];
  while (!curElt.tail) {
    if (this.type === types$1.eof) {
      this.raise(this.pos, "Unterminated template literal");
    }
    this.expect(types$1.dollarBraceL);
    node2.expressions.push(this.parseExpression());
    this.expect(types$1.braceR);
    node2.quasis.push(curElt = this.parseTemplateElement({ isTagged }));
  }
  this.next();
  return this.finishNode(node2, "TemplateLiteral");
};
pp$5.isAsyncProp = function(prop) {
  return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && (this.type === types$1.name || this.type === types$1.num || this.type === types$1.string || this.type === types$1.bracketL || this.type.keyword || this.options.ecmaVersion >= 9 && this.type === types$1.star) && !lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
};
pp$5.parseObj = function(isPattern, refDestructuringErrors) {
  var node2 = this.startNode(), first = true, propHash = {};
  node2.properties = [];
  this.next();
  while (!this.eat(types$1.braceR)) {
    if (!first) {
      this.expect(types$1.comma);
      if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types$1.braceR)) {
        break;
      }
    } else {
      first = false;
    }
    var prop = this.parseProperty(isPattern, refDestructuringErrors);
    if (!isPattern) {
      this.checkPropClash(prop, propHash, refDestructuringErrors);
    }
    node2.properties.push(prop);
  }
  return this.finishNode(node2, isPattern ? "ObjectPattern" : "ObjectExpression");
};
pp$5.parseProperty = function(isPattern, refDestructuringErrors) {
  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
  if (this.options.ecmaVersion >= 9 && this.eat(types$1.ellipsis)) {
    if (isPattern) {
      prop.argument = this.parseIdent(false);
      if (this.type === types$1.comma) {
        this.raise(this.start, "Comma is not permitted after the rest element");
      }
      return this.finishNode(prop, "RestElement");
    }
    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
    if (this.type === types$1.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
      refDestructuringErrors.trailingComma = this.start;
    }
    return this.finishNode(prop, "SpreadElement");
  }
  if (this.options.ecmaVersion >= 6) {
    prop.method = false;
    prop.shorthand = false;
    if (isPattern || refDestructuringErrors) {
      startPos = this.start;
      startLoc = this.startLoc;
    }
    if (!isPattern) {
      isGenerator = this.eat(types$1.star);
    }
  }
  var containsEsc = this.containsEsc;
  this.parsePropertyName(prop);
  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
    isAsync = true;
    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types$1.star);
    this.parsePropertyName(prop);
  } else {
    isAsync = false;
  }
  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
  return this.finishNode(prop, "Property");
};
pp$5.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
  if ((isGenerator || isAsync) && this.type === types$1.colon) {
    this.unexpected();
  }
  if (this.eat(types$1.colon)) {
    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
    prop.kind = "init";
  } else if (this.options.ecmaVersion >= 6 && this.type === types$1.parenL) {
    if (isPattern) {
      this.unexpected();
    }
    prop.kind = "init";
    prop.method = true;
    prop.value = this.parseMethod(isGenerator, isAsync);
  } else if (!isPattern && !containsEsc && this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (this.type !== types$1.comma && this.type !== types$1.braceR && this.type !== types$1.eq)) {
    if (isGenerator || isAsync) {
      this.unexpected();
    }
    prop.kind = prop.key.name;
    this.parsePropertyName(prop);
    prop.value = this.parseMethod(false);
    var paramCount = prop.kind === "get" ? 0 : 1;
    if (prop.value.params.length !== paramCount) {
      var start3 = prop.value.start;
      if (prop.kind === "get") {
        this.raiseRecoverable(start3, "getter should have no params");
      } else {
        this.raiseRecoverable(start3, "setter should have exactly one param");
      }
    } else {
      if (prop.kind === "set" && prop.value.params[0].type === "RestElement") {
        this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params");
      }
    }
  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
    if (isGenerator || isAsync) {
      this.unexpected();
    }
    this.checkUnreserved(prop.key);
    if (prop.key.name === "await" && !this.awaitIdentPos) {
      this.awaitIdentPos = startPos;
    }
    prop.kind = "init";
    if (isPattern) {
      prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
    } else if (this.type === types$1.eq && refDestructuringErrors) {
      if (refDestructuringErrors.shorthandAssign < 0) {
        refDestructuringErrors.shorthandAssign = this.start;
      }
      prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
    } else {
      prop.value = this.copyNode(prop.key);
    }
    prop.shorthand = true;
  } else {
    this.unexpected();
  }
};
pp$5.parsePropertyName = function(prop) {
  if (this.options.ecmaVersion >= 6) {
    if (this.eat(types$1.bracketL)) {
      prop.computed = true;
      prop.key = this.parseMaybeAssign();
      this.expect(types$1.bracketR);
      return prop.key;
    } else {
      prop.computed = false;
    }
  }
  return prop.key = this.type === types$1.num || this.type === types$1.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never");
};
pp$5.initFunction = function(node2) {
  node2.id = null;
  if (this.options.ecmaVersion >= 6) {
    node2.generator = node2.expression = false;
  }
  if (this.options.ecmaVersion >= 8) {
    node2.async = false;
  }
};
pp$5.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
  var node2 = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
  this.initFunction(node2);
  if (this.options.ecmaVersion >= 6) {
    node2.generator = isGenerator;
  }
  if (this.options.ecmaVersion >= 8) {
    node2.async = !!isAsync;
  }
  this.yieldPos = 0;
  this.awaitPos = 0;
  this.awaitIdentPos = 0;
  this.enterScope(functionFlags(isAsync, node2.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
  this.expect(types$1.parenL);
  node2.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8);
  this.checkYieldAwaitInDefaultParams();
  this.parseFunctionBody(node2, false, true, false);
  this.yieldPos = oldYieldPos;
  this.awaitPos = oldAwaitPos;
  this.awaitIdentPos = oldAwaitIdentPos;
  return this.finishNode(node2, "FunctionExpression");
};
pp$5.parseArrowExpression = function(node2, params, isAsync, forInit) {
  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);
  this.initFunction(node2);
  if (this.options.ecmaVersion >= 8) {
    node2.async = !!isAsync;
  }
  this.yieldPos = 0;
  this.awaitPos = 0;
  this.awaitIdentPos = 0;
  node2.params = this.toAssignableList(params, true);
  this.parseFunctionBody(node2, true, false, forInit);
  this.yieldPos = oldYieldPos;
  this.awaitPos = oldAwaitPos;
  this.awaitIdentPos = oldAwaitIdentPos;
  return this.finishNode(node2, "ArrowFunctionExpression");
};
pp$5.parseFunctionBody = function(node2, isArrowFunction, isMethod, forInit) {
  var isExpression = isArrowFunction && this.type !== types$1.braceL;
  var oldStrict = this.strict, useStrict = false;
  if (isExpression) {
    node2.body = this.parseMaybeAssign(forInit);
    node2.expression = true;
    this.checkParams(node2, false);
  } else {
    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node2.params);
    if (!oldStrict || nonSimple) {
      useStrict = this.strictDirective(this.end);
      if (useStrict && nonSimple) {
        this.raiseRecoverable(node2.start, "Illegal 'use strict' directive in function with non-simple parameter list");
      }
    }
    var oldLabels = this.labels;
    this.labels = [];
    if (useStrict) {
      this.strict = true;
    }
    this.checkParams(node2, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node2.params));
    if (this.strict && node2.id) {
      this.checkLValSimple(node2.id, BIND_OUTSIDE);
    }
    node2.body = this.parseBlock(false, void 0, useStrict && !oldStrict);
    node2.expression = false;
    this.adaptDirectivePrologue(node2.body.body);
    this.labels = oldLabels;
  }
  this.exitScope();
};
pp$5.isSimpleParamList = function(params) {
  for (var i = 0, list3 = params; i < list3.length; i += 1) {
    var param = list3[i];
    if (param.type !== "Identifier") {
      return false;
    }
  }
  return true;
};
pp$5.checkParams = function(node2, allowDuplicates) {
  var nameHash = /* @__PURE__ */ Object.create(null);
  for (var i = 0, list3 = node2.params; i < list3.length; i += 1) {
    var param = list3[i];
    this.checkLValInnerPattern(param, BIND_VAR, allowDuplicates ? null : nameHash);
  }
};
pp$5.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
  var elts = [], first = true;
  while (!this.eat(close)) {
    if (!first) {
      this.expect(types$1.comma);
      if (allowTrailingComma && this.afterTrailingComma(close)) {
        break;
      }
    } else {
      first = false;
    }
    var elt = void 0;
    if (allowEmpty && this.type === types$1.comma) {
      elt = null;
    } else if (this.type === types$1.ellipsis) {
      elt = this.parseSpread(refDestructuringErrors);
      if (refDestructuringErrors && this.type === types$1.comma && refDestructuringErrors.trailingComma < 0) {
        refDestructuringErrors.trailingComma = this.start;
      }
    } else {
      elt = this.parseMaybeAssign(false, refDestructuringErrors);
    }
    elts.push(elt);
  }
  return elts;
};
pp$5.checkUnreserved = function(ref3) {
  var start3 = ref3.start;
  var end = ref3.end;
  var name2 = ref3.name;
  if (this.inGenerator && name2 === "yield") {
    this.raiseRecoverable(start3, "Cannot use 'yield' as identifier inside a generator");
  }
  if (this.inAsync && name2 === "await") {
    this.raiseRecoverable(start3, "Cannot use 'await' as identifier inside an async function");
  }
  if (this.currentThisScope().inClassFieldInit && name2 === "arguments") {
    this.raiseRecoverable(start3, "Cannot use 'arguments' in class field initializer");
  }
  if (this.inClassStaticBlock && (name2 === "arguments" || name2 === "await")) {
    this.raise(start3, "Cannot use " + name2 + " in class static initialization block");
  }
  if (this.keywords.test(name2)) {
    this.raise(start3, "Unexpected keyword '" + name2 + "'");
  }
  if (this.options.ecmaVersion < 6 && this.input.slice(start3, end).indexOf("\\") !== -1) {
    return;
  }
  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
  if (re.test(name2)) {
    if (!this.inAsync && name2 === "await") {
      this.raiseRecoverable(start3, "Cannot use keyword 'await' outside an async function");
    }
    this.raiseRecoverable(start3, "The keyword '" + name2 + "' is reserved");
  }
};
pp$5.parseIdent = function(liberal) {
  var node2 = this.startNode();
  if (this.type === types$1.name) {
    node2.name = this.value;
  } else if (this.type.keyword) {
    node2.name = this.type.keyword;
    if ((node2.name === "class" || node2.name === "function") && (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
      this.context.pop();
    }
  } else {
    this.unexpected();
  }
  this.next(!!liberal);
  this.finishNode(node2, "Identifier");
  if (!liberal) {
    this.checkUnreserved(node2);
    if (node2.name === "await" && !this.awaitIdentPos) {
      this.awaitIdentPos = node2.start;
    }
  }
  return node2;
};
pp$5.parsePrivateIdent = function() {
  var node2 = this.startNode();
  if (this.type === types$1.privateId) {
    node2.name = this.value;
  } else {
    this.unexpected();
  }
  this.next();
  this.finishNode(node2, "PrivateIdentifier");
  if (this.privateNameStack.length === 0) {
    this.raise(node2.start, "Private field '#" + node2.name + "' must be declared in an enclosing class");
  } else {
    this.privateNameStack[this.privateNameStack.length - 1].used.push(node2);
  }
  return node2;
};
pp$5.parseYield = function(forInit) {
  if (!this.yieldPos) {
    this.yieldPos = this.start;
  }
  var node2 = this.startNode();
  this.next();
  if (this.type === types$1.semi || this.canInsertSemicolon() || this.type !== types$1.star && !this.type.startsExpr) {
    node2.delegate = false;
    node2.argument = null;
  } else {
    node2.delegate = this.eat(types$1.star);
    node2.argument = this.parseMaybeAssign(forInit);
  }
  return this.finishNode(node2, "YieldExpression");
};
pp$5.parseAwait = function(forInit) {
  if (!this.awaitPos) {
    this.awaitPos = this.start;
  }
  var node2 = this.startNode();
  this.next();
  node2.argument = this.parseMaybeUnary(null, true, false, forInit);
  return this.finishNode(node2, "AwaitExpression");
};
var pp$4 = Parser.prototype;
pp$4.raise = function(pos2, message) {
  var loc = getLineInfo(this.input, pos2);
  message += " (" + loc.line + ":" + loc.column + ")";
  var err = new SyntaxError(message);
  err.pos = pos2;
  err.loc = loc;
  err.raisedAt = this.pos;
  throw err;
};
pp$4.raiseRecoverable = pp$4.raise;
pp$4.curPosition = function() {
  if (this.options.locations) {
    return new Position(this.curLine, this.pos - this.lineStart);
  }
};
var pp$3 = Parser.prototype;
var Scope = function Scope2(flags) {
  this.flags = flags;
  this.var = [];
  this.lexical = [];
  this.functions = [];
  this.inClassFieldInit = false;
};
pp$3.enterScope = function(flags) {
  this.scopeStack.push(new Scope(flags));
};
pp$3.exitScope = function() {
  this.scopeStack.pop();
};
pp$3.treatFunctionsAsVarInScope = function(scope) {
  return scope.flags & SCOPE_FUNCTION || !this.inModule && scope.flags & SCOPE_TOP;
};
pp$3.declareName = function(name2, bindingType, pos2) {
  var redeclared = false;
  if (bindingType === BIND_LEXICAL) {
    var scope = this.currentScope();
    redeclared = scope.lexical.indexOf(name2) > -1 || scope.functions.indexOf(name2) > -1 || scope.var.indexOf(name2) > -1;
    scope.lexical.push(name2);
    if (this.inModule && scope.flags & SCOPE_TOP) {
      delete this.undefinedExports[name2];
    }
  } else if (bindingType === BIND_SIMPLE_CATCH) {
    var scope$1 = this.currentScope();
    scope$1.lexical.push(name2);
  } else if (bindingType === BIND_FUNCTION) {
    var scope$2 = this.currentScope();
    if (this.treatFunctionsAsVar) {
      redeclared = scope$2.lexical.indexOf(name2) > -1;
    } else {
      redeclared = scope$2.lexical.indexOf(name2) > -1 || scope$2.var.indexOf(name2) > -1;
    }
    scope$2.functions.push(name2);
  } else {
    for (var i = this.scopeStack.length - 1; i >= 0; --i) {
      var scope$3 = this.scopeStack[i];
      if (scope$3.lexical.indexOf(name2) > -1 && !(scope$3.flags & SCOPE_SIMPLE_CATCH && scope$3.lexical[0] === name2) || !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name2) > -1) {
        redeclared = true;
        break;
      }
      scope$3.var.push(name2);
      if (this.inModule && scope$3.flags & SCOPE_TOP) {
        delete this.undefinedExports[name2];
      }
      if (scope$3.flags & SCOPE_VAR) {
        break;
      }
    }
  }
  if (redeclared) {
    this.raiseRecoverable(pos2, "Identifier '" + name2 + "' has already been declared");
  }
};
pp$3.checkLocalExport = function(id) {
  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 && this.scopeStack[0].var.indexOf(id.name) === -1) {
    this.undefinedExports[id.name] = id;
  }
};
pp$3.currentScope = function() {
  return this.scopeStack[this.scopeStack.length - 1];
};
pp$3.currentVarScope = function() {
  for (var i = this.scopeStack.length - 1; ; i--) {
    var scope = this.scopeStack[i];
    if (scope.flags & SCOPE_VAR) {
      return scope;
    }
  }
};
pp$3.currentThisScope = function() {
  for (var i = this.scopeStack.length - 1; ; i--) {
    var scope = this.scopeStack[i];
    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) {
      return scope;
    }
  }
};
var Node = function Node2(parser, pos2, loc) {
  this.type = "";
  this.start = pos2;
  this.end = 0;
  if (parser.options.locations) {
    this.loc = new SourceLocation(parser, loc);
  }
  if (parser.options.directSourceFile) {
    this.sourceFile = parser.options.directSourceFile;
  }
  if (parser.options.ranges) {
    this.range = [pos2, 0];
  }
};
var pp$2 = Parser.prototype;
pp$2.startNode = function() {
  return new Node(this, this.start, this.startLoc);
};
pp$2.startNodeAt = function(pos2, loc) {
  return new Node(this, pos2, loc);
};
function finishNodeAt(node2, type, pos2, loc) {
  node2.type = type;
  node2.end = pos2;
  if (this.options.locations) {
    node2.loc.end = loc;
  }
  if (this.options.ranges) {
    node2.range[1] = pos2;
  }
  return node2;
}
pp$2.finishNode = function(node2, type) {
  return finishNodeAt.call(this, node2, type, this.lastTokEnd, this.lastTokEndLoc);
};
pp$2.finishNodeAt = function(node2, type, pos2, loc) {
  return finishNodeAt.call(this, node2, type, pos2, loc);
};
pp$2.copyNode = function(node2) {
  var newNode = new Node(this, node2.start, this.startLoc);
  for (var prop in node2) {
    newNode[prop] = node2[prop];
  }
  return newNode;
};
var ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
var ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic";
var ecma11BinaryProperties = ecma10BinaryProperties;
var ecma12BinaryProperties = ecma11BinaryProperties + " EBase EComp EMod EPres ExtPict";
var ecma13BinaryProperties = ecma12BinaryProperties;
var ecma14BinaryProperties = ecma13BinaryProperties;
var unicodeBinaryProperties = {
  9: ecma9BinaryProperties,
  10: ecma10BinaryProperties,
  11: ecma11BinaryProperties,
  12: ecma12BinaryProperties,
  13: ecma13BinaryProperties,
  14: ecma14BinaryProperties
};
var unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu";
var ecma9ScriptValues = "Adlam Adlm Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
var ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
var ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
var ecma12ScriptValues = ecma11ScriptValues + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi";
var ecma13ScriptValues = ecma12ScriptValues + " Cypro_Minoan Cpmn Old_Uyghur Ougr Tangsa Tnsa Toto Vithkuqi Vith";
var ecma14ScriptValues = ecma13ScriptValues + " Kawi Nag_Mundari Nagm";
var unicodeScriptValues = {
  9: ecma9ScriptValues,
  10: ecma10ScriptValues,
  11: ecma11ScriptValues,
  12: ecma12ScriptValues,
  13: ecma13ScriptValues,
  14: ecma14ScriptValues
};
var data = {};
function buildUnicodeData(ecmaVersion) {
  var d = data[ecmaVersion] = {
    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues),
    nonBinary: {
      General_Category: wordsRegexp(unicodeGeneralCategoryValues),
      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])
    }
  };
  d.nonBinary.Script_Extensions = d.nonBinary.Script;
  d.nonBinary.gc = d.nonBinary.General_Category;
  d.nonBinary.sc = d.nonBinary.Script;
  d.nonBinary.scx = d.nonBinary.Script_Extensions;
}
for (i = 0, list3 = [9, 10, 11, 12, 13, 14]; i < list3.length; i += 1) {
  ecmaVersion = list3[i];
  buildUnicodeData(ecmaVersion);
}
var ecmaVersion;
var i;
var list3;
var pp$1 = Parser.prototype;
var RegExpValidationState = function RegExpValidationState2(parser) {
  this.parser = parser;
  this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "") + (parser.options.ecmaVersion >= 13 ? "d" : "");
  this.unicodeProperties = data[parser.options.ecmaVersion >= 14 ? 14 : parser.options.ecmaVersion];
  this.source = "";
  this.flags = "";
  this.start = 0;
  this.switchU = false;
  this.switchN = false;
  this.pos = 0;
  this.lastIntValue = 0;
  this.lastStringValue = "";
  this.lastAssertionIsQuantifiable = false;
  this.numCapturingParens = 0;
  this.maxBackReference = 0;
  this.groupNames = [];
  this.backReferenceNames = [];
};
RegExpValidationState.prototype.reset = function reset(start3, pattern, flags) {
  var unicode2 = flags.indexOf("u") !== -1;
  this.start = start3 | 0;
  this.source = pattern + "";
  this.flags = flags;
  this.switchU = unicode2 && this.parser.options.ecmaVersion >= 6;
  this.switchN = unicode2 && this.parser.options.ecmaVersion >= 9;
};
RegExpValidationState.prototype.raise = function raise(message) {
  this.parser.raiseRecoverable(this.start, "Invalid regular expression: /" + this.source + "/: " + message);
};
RegExpValidationState.prototype.at = function at(i, forceU) {
  if (forceU === void 0)
    forceU = false;
  var s = this.source;
  var l = s.length;
  if (i >= l) {
    return -1;
  }
  var c2 = s.charCodeAt(i);
  if (!(forceU || this.switchU) || c2 <= 55295 || c2 >= 57344 || i + 1 >= l) {
    return c2;
  }
  var next = s.charCodeAt(i + 1);
  return next >= 56320 && next <= 57343 ? (c2 << 10) + next - 56613888 : c2;
};
RegExpValidationState.prototype.nextIndex = function nextIndex(i, forceU) {
  if (forceU === void 0)
    forceU = false;
  var s = this.source;
  var l = s.length;
  if (i >= l) {
    return l;
  }
  var c2 = s.charCodeAt(i), next;
  if (!(forceU || this.switchU) || c2 <= 55295 || c2 >= 57344 || i + 1 >= l || (next = s.charCodeAt(i + 1)) < 56320 || next > 57343) {
    return i + 1;
  }
  return i + 2;
};
RegExpValidationState.prototype.current = function current(forceU) {
  if (forceU === void 0)
    forceU = false;
  return this.at(this.pos, forceU);
};
RegExpValidationState.prototype.lookahead = function lookahead(forceU) {
  if (forceU === void 0)
    forceU = false;
  return this.at(this.nextIndex(this.pos, forceU), forceU);
};
RegExpValidationState.prototype.advance = function advance(forceU) {
  if (forceU === void 0)
    forceU = false;
  this.pos = this.nextIndex(this.pos, forceU);
};
RegExpValidationState.prototype.eat = function eat(ch, forceU) {
  if (forceU === void 0)
    forceU = false;
  if (this.current(forceU) === ch) {
    this.advance(forceU);
    return true;
  }
  return false;
};
pp$1.validateRegExpFlags = function(state) {
  var validFlags = state.validFlags;
  var flags = state.flags;
  for (var i = 0; i < flags.length; i++) {
    var flag = flags.charAt(i);
    if (validFlags.indexOf(flag) === -1) {
      this.raise(state.start, "Invalid regular expression flag");
    }
    if (flags.indexOf(flag, i + 1) > -1) {
      this.raise(state.start, "Duplicate regular expression flag");
    }
  }
};
pp$1.validateRegExpPattern = function(state) {
  this.regexp_pattern(state);
  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
    state.switchN = true;
    this.regexp_pattern(state);
  }
};
pp$1.regexp_pattern = function(state) {
  state.pos = 0;
  state.lastIntValue = 0;
  state.lastStringValue = "";
  state.lastAssertionIsQuantifiable = false;
  state.numCapturingParens = 0;
  state.maxBackReference = 0;
  state.groupNames.length = 0;
  state.backReferenceNames.length = 0;
  this.regexp_disjunction(state);
  if (state.pos !== state.source.length) {
    if (state.eat(
      41
      /* ) */
    )) {
      state.raise("Unmatched ')'");
    }
    if (state.eat(
      93
      /* ] */
    ) || state.eat(
      125
      /* } */
    )) {
      state.raise("Lone quantifier brackets");
    }
  }
  if (state.maxBackReference > state.numCapturingParens) {
    state.raise("Invalid escape");
  }
  for (var i = 0, list3 = state.backReferenceNames; i < list3.length; i += 1) {
    var name2 = list3[i];
    if (state.groupNames.indexOf(name2) === -1) {
      state.raise("Invalid named capture referenced");
    }
  }
};
pp$1.regexp_disjunction = function(state) {
  this.regexp_alternative(state);
  while (state.eat(
    124
    /* | */
  )) {
    this.regexp_alternative(state);
  }
  if (this.regexp_eatQuantifier(state, true)) {
    state.raise("Nothing to repeat");
  }
  if (state.eat(
    123
    /* { */
  )) {
    state.raise("Lone quantifier brackets");
  }
};
pp$1.regexp_alternative = function(state) {
  while (state.pos < state.source.length && this.regexp_eatTerm(state)) {
  }
};
pp$1.regexp_eatTerm = function(state) {
  if (this.regexp_eatAssertion(state)) {
    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
      if (state.switchU) {
        state.raise("Invalid quantifier");
      }
    }
    return true;
  }
  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
    this.regexp_eatQuantifier(state);
    return true;
  }
  return false;
};
pp$1.regexp_eatAssertion = function(state) {
  var start3 = state.pos;
  state.lastAssertionIsQuantifiable = false;
  if (state.eat(
    94
    /* ^ */
  ) || state.eat(
    36
    /* $ */
  )) {
    return true;
  }
  if (state.eat(
    92
    /* \ */
  )) {
    if (state.eat(
      66
      /* B */
    ) || state.eat(
      98
      /* b */
    )) {
      return true;
    }
    state.pos = start3;
  }
  if (state.eat(
    40
    /* ( */
  ) && state.eat(
    63
    /* ? */
  )) {
    var lookbehind = false;
    if (this.options.ecmaVersion >= 9) {
      lookbehind = state.eat(
        60
        /* < */
      );
    }
    if (state.eat(
      61
      /* = */
    ) || state.eat(
      33
      /* ! */
    )) {
      this.regexp_disjunction(state);
      if (!state.eat(
        41
        /* ) */
      )) {
        state.raise("Unterminated group");
      }
      state.lastAssertionIsQuantifiable = !lookbehind;
      return true;
    }
  }
  state.pos = start3;
  return false;
};
pp$1.regexp_eatQuantifier = function(state, noError) {
  if (noError === void 0)
    noError = false;
  if (this.regexp_eatQuantifierPrefix(state, noError)) {
    state.eat(
      63
      /* ? */
    );
    return true;
  }
  return false;
};
pp$1.regexp_eatQuantifierPrefix = function(state, noError) {
  return state.eat(
    42
    /* * */
  ) || state.eat(
    43
    /* + */
  ) || state.eat(
    63
    /* ? */
  ) || this.regexp_eatBracedQuantifier(state, noError);
};
pp$1.regexp_eatBracedQuantifier = function(state, noError) {
  var start3 = state.pos;
  if (state.eat(
    123
    /* { */
  )) {
    var min = 0, max = -1;
    if (this.regexp_eatDecimalDigits(state)) {
      min = state.lastIntValue;
      if (state.eat(
        44
        /* , */
      ) && this.regexp_eatDecimalDigits(state)) {
        max = state.lastIntValue;
      }
      if (state.eat(
        125
        /* } */
      )) {
        if (max !== -1 && max < min && !noError) {
          state.raise("numbers out of order in {} quantifier");
        }
        return true;
      }
    }
    if (state.switchU && !noError) {
      state.raise("Incomplete quantifier");
    }
    state.pos = start3;
  }
  return false;
};
pp$1.regexp_eatAtom = function(state) {
  return this.regexp_eatPatternCharacters(state) || state.eat(
    46
    /* . */
  ) || this.regexp_eatReverseSolidusAtomEscape(state) || this.regexp_eatCharacterClass(state) || this.regexp_eatUncapturingGroup(state) || this.regexp_eatCapturingGroup(state);
};
pp$1.regexp_eatReverseSolidusAtomEscape = function(state) {
  var start3 = state.pos;
  if (state.eat(
    92
    /* \ */
  )) {
    if (this.regexp_eatAtomEscape(state)) {
      return true;
    }
    state.pos = start3;
  }
  return false;
};
pp$1.regexp_eatUncapturingGroup = function(state) {
  var start3 = state.pos;
  if (state.eat(
    40
    /* ( */
  )) {
    if (state.eat(
      63
      /* ? */
    ) && state.eat(
      58
      /* : */
    )) {
      this.regexp_disjunction(state);
      if (state.eat(
        41
        /* ) */
      )) {
        return true;
      }
      state.raise("Unterminated group");
    }
    state.pos = start3;
  }
  return false;
};
pp$1.regexp_eatCapturingGroup = function(state) {
  if (state.eat(
    40
    /* ( */
  )) {
    if (this.options.ecmaVersion >= 9) {
      this.regexp_groupSpecifier(state);
    } else if (state.current() === 63) {
      state.raise("Invalid group");
    }
    this.regexp_disjunction(state);
    if (state.eat(
      41
      /* ) */
    )) {
      state.numCapturingParens += 1;
      return true;
    }
    state.raise("Unterminated group");
  }
  return false;
};
pp$1.regexp_eatExtendedAtom = function(state) {
  return state.eat(
    46
    /* . */
  ) || this.regexp_eatReverseSolidusAtomEscape(state) || this.regexp_eatCharacterClass(state) || this.regexp_eatUncapturingGroup(state) || this.regexp_eatCapturingGroup(state) || this.regexp_eatInvalidBracedQuantifier(state) || this.regexp_eatExtendedPatternCharacter(state);
};
pp$1.regexp_eatInvalidBracedQuantifier = function(state) {
  if (this.regexp_eatBracedQuantifier(state, true)) {
    state.raise("Nothing to repeat");
  }
  return false;
};
pp$1.regexp_eatSyntaxCharacter = function(state) {
  var ch = state.current();
  if (isSyntaxCharacter(ch)) {
    state.lastIntValue = ch;
    state.advance();
    return true;
  }
  return false;
};
function isSyntaxCharacter(ch) {
  return ch === 36 || ch >= 40 && ch <= 43 || ch === 46 || ch === 63 || ch >= 91 && ch <= 94 || ch >= 123 && ch <= 125;
}
pp$1.regexp_eatPatternCharacters = function(state) {
  var start3 = state.pos;
  var ch = 0;
  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
    state.advance();
  }
  return state.pos !== start3;
};
pp$1.regexp_eatExtendedPatternCharacter = function(state) {
  var ch = state.current();
  if (ch !== -1 && ch !== 36 && !(ch >= 40 && ch <= 43) && ch !== 46 && ch !== 63 && ch !== 91 && ch !== 94 && ch !== 124) {
    state.advance();
    return true;
  }
  return false;
};
pp$1.regexp_groupSpecifier = function(state) {
  if (state.eat(
    63
    /* ? */
  )) {
    if (this.regexp_eatGroupName(state)) {
      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
        state.raise("Duplicate capture group name");
      }
      state.groupNames.push(state.lastStringValue);
      return;
    }
    state.raise("Invalid group");
  }
};
pp$1.regexp_eatGroupName = function(state) {
  state.lastStringValue = "";
  if (state.eat(
    60
    /* < */
  )) {
    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(
      62
      /* > */
    )) {
      return true;
    }
    state.raise("Invalid capture group name");
  }
  return false;
};
pp$1.regexp_eatRegExpIdentifierName = function(state) {
  state.lastStringValue = "";
  if (this.regexp_eatRegExpIdentifierStart(state)) {
    state.lastStringValue += codePointToString(state.lastIntValue);
    while (this.regexp_eatRegExpIdentifierPart(state)) {
      state.lastStringValue += codePointToString(state.lastIntValue);
    }
    return true;
  }
  return false;
};
pp$1.regexp_eatRegExpIdentifierStart = function(state) {
  var start3 = state.pos;
  var forceU = this.options.ecmaVersion >= 11;
  var ch = state.current(forceU);
  state.advance(forceU);
  if (ch === 92 && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
    ch = state.lastIntValue;
  }
  if (isRegExpIdentifierStart(ch)) {
    state.lastIntValue = ch;
    return true;
  }
  state.pos = start3;
  return false;
};
function isRegExpIdentifierStart(ch) {
  return isIdentifierStart(ch, true) || ch === 36 || ch === 95;
}
pp$1.regexp_eatRegExpIdentifierPart = function(state) {
  var start3 = state.pos;
  var forceU = this.options.ecmaVersion >= 11;
  var ch = state.current(forceU);
  state.advance(forceU);
  if (ch === 92 && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
    ch = state.lastIntValue;
  }
  if (isRegExpIdentifierPart(ch)) {
    state.lastIntValue = ch;
    return true;
  }
  state.pos = start3;
  return false;
};
function isRegExpIdentifierPart(ch) {
  return isIdentifierChar(ch, true) || ch === 36 || ch === 95 || ch === 8204 || ch === 8205;
}
pp$1.regexp_eatAtomEscape = function(state) {
  if (this.regexp_eatBackReference(state) || this.regexp_eatCharacterClassEscape(state) || this.regexp_eatCharacterEscape(state) || state.switchN && this.regexp_eatKGroupName(state)) {
    return true;
  }
  if (state.switchU) {
    if (state.current() === 99) {
      state.raise("Invalid unicode escape");
    }
    state.raise("Invalid escape");
  }
  return false;
};
pp$1.regexp_eatBackReference = function(state) {
  var start3 = state.pos;
  if (this.regexp_eatDecimalEscape(state)) {
    var n = state.lastIntValue;
    if (state.switchU) {
      if (n > state.maxBackReference) {
        state.maxBackReference = n;
      }
      return true;
    }
    if (n <= state.numCapturingParens) {
      return true;
    }
    state.pos = start3;
  }
  return false;
};
pp$1.regexp_eatKGroupName = function(state) {
  if (state.eat(
    107
    /* k */
  )) {
    if (this.regexp_eatGroupName(state)) {
      state.backReferenceNames.push(state.lastStringValue);
      return true;
    }
    state.raise("Invalid named reference");
  }
  return false;
};
pp$1.regexp_eatCharacterEscape = function(state) {
  return this.regexp_eatControlEscape(state) || this.regexp_eatCControlLetter(state) || this.regexp_eatZero(state) || this.regexp_eatHexEscapeSequence(state) || this.regexp_eatRegExpUnicodeEscapeSequence(state, false) || !state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state) || this.regexp_eatIdentityEscape(state);
};
pp$1.regexp_eatCControlLetter = function(state) {
  var start3 = state.pos;
  if (state.eat(
    99
    /* c */
  )) {
    if (this.regexp_eatControlLetter(state)) {
      return true;
    }
    state.pos = start3;
  }
  return false;
};
pp$1.regexp_eatZero = function(state) {
  if (state.current() === 48 && !isDecimalDigit(state.lookahead())) {
    state.lastIntValue = 0;
    state.advance();
    return true;
  }
  return false;
};
pp$1.regexp_eatControlEscape = function(state) {
  var ch = state.current();
  if (ch === 116) {
    state.lastIntValue = 9;
    state.advance();
    return true;
  }
  if (ch === 110) {
    state.lastIntValue = 10;
    state.advance();
    return true;
  }
  if (ch === 118) {
    state.lastIntValue = 11;
    state.advance();
    return true;
  }
  if (ch === 102) {
    state.lastIntValue = 12;
    state.advance();
    return true;
  }
  if (ch === 114) {
    state.lastIntValue = 13;
    state.advance();
    return true;
  }
  return false;
};
pp$1.regexp_eatControlLetter = function(state) {
  var ch = state.current();
  if (isControlLetter(ch)) {
    state.lastIntValue = ch % 32;
    state.advance();
    return true;
  }
  return false;
};
function isControlLetter(ch) {
  return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122;
}
pp$1.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {
  if (forceU === void 0)
    forceU = false;
  var start3 = state.pos;
  var switchU = forceU || state.switchU;
  if (state.eat(
    117
    /* u */
  )) {
    if (this.regexp_eatFixedHexDigits(state, 4)) {
      var lead = state.lastIntValue;
      if (switchU && lead >= 55296 && lead <= 56319) {
        var leadSurrogateEnd = state.pos;
        if (state.eat(
          92
          /* \ */
        ) && state.eat(
          117
          /* u */
        ) && this.regexp_eatFixedHexDigits(state, 4)) {
          var trail = state.lastIntValue;
          if (trail >= 56320 && trail <= 57343) {
            state.lastIntValue = (lead - 55296) * 1024 + (trail - 56320) + 65536;
            return true;
          }
        }
        state.pos = leadSurrogateEnd;
        state.lastIntValue = lead;
      }
      return true;
    }
    if (switchU && state.eat(
      123
      /* { */
    ) && this.regexp_eatHexDigits(state) && state.eat(
      125
      /* } */
    ) && isValidUnicode(state.lastIntValue)) {
      return true;
    }
    if (switchU) {
      state.raise("Invalid unicode escape");
    }
    state.pos = start3;
  }
  return false;
};
function isValidUnicode(ch) {
  return ch >= 0 && ch <= 1114111;
}
pp$1.regexp_eatIdentityEscape = function(state) {
  if (state.switchU) {
    if (this.regexp_eatSyntaxCharacter(state)) {
      return true;
    }
    if (state.eat(
      47
      /* / */
    )) {
      state.lastIntValue = 47;
      return true;
    }
    return false;
  }
  var ch = state.current();
  if (ch !== 99 && (!state.switchN || ch !== 107)) {
    state.lastIntValue = ch;
    state.advance();
    return true;
  }
  return false;
};
pp$1.regexp_eatDecimalEscape = function(state) {
  state.lastIntValue = 0;
  var ch = state.current();
  if (ch >= 49 && ch <= 57) {
    do {
      state.lastIntValue = 10 * state.lastIntValue + (ch - 48);
      state.advance();
    } while ((ch = state.current()) >= 48 && ch <= 57);
    return true;
  }
  return false;
};
pp$1.regexp_eatCharacterClassEscape = function(state) {
  var ch = state.current();
  if (isCharacterClassEscape(ch)) {
    state.lastIntValue = -1;
    state.advance();
    return true;
  }
  if (state.switchU && this.options.ecmaVersion >= 9 && (ch === 80 || ch === 112)) {
    state.lastIntValue = -1;
    state.advance();
    if (state.eat(
      123
      /* { */
    ) && this.regexp_eatUnicodePropertyValueExpression(state) && state.eat(
      125
      /* } */
    )) {
      return true;
    }
    state.raise("Invalid property name");
  }
  return false;
};
function isCharacterClassEscape(ch) {
  return ch === 100 || ch === 68 || ch === 115 || ch === 83 || ch === 119 || ch === 87;
}
pp$1.regexp_eatUnicodePropertyValueExpression = function(state) {
  var start3 = state.pos;
  if (this.regexp_eatUnicodePropertyName(state) && state.eat(
    61
    /* = */
  )) {
    var name2 = state.lastStringValue;
    if (this.regexp_eatUnicodePropertyValue(state)) {
      var value2 = state.lastStringValue;
      this.regexp_validateUnicodePropertyNameAndValue(state, name2, value2);
      return true;
    }
  }
  state.pos = start3;
  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
    var nameOrValue = state.lastStringValue;
    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
    return true;
  }
  return false;
};
pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name2, value2) {
  if (!hasOwn(state.unicodeProperties.nonBinary, name2)) {
    state.raise("Invalid property name");
  }
  if (!state.unicodeProperties.nonBinary[name2].test(value2)) {
    state.raise("Invalid property value");
  }
};
pp$1.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
  if (!state.unicodeProperties.binary.test(nameOrValue)) {
    state.raise("Invalid property name");
  }
};
pp$1.regexp_eatUnicodePropertyName = function(state) {
  var ch = 0;
  state.lastStringValue = "";
  while (isUnicodePropertyNameCharacter(ch = state.current())) {
    state.lastStringValue += codePointToString(ch);
    state.advance();
  }
  return state.lastStringValue !== "";
};
function isUnicodePropertyNameCharacter(ch) {
  return isControlLetter(ch) || ch === 95;
}
pp$1.regexp_eatUnicodePropertyValue = function(state) {
  var ch = 0;
  state.lastStringValue = "";
  while (isUnicodePropertyValueCharacter(ch = state.current())) {
    state.lastStringValue += codePointToString(ch);
    state.advance();
  }
  return state.lastStringValue !== "";
};
function isUnicodePropertyValueCharacter(ch) {
  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch);
}
pp$1.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
  return this.regexp_eatUnicodePropertyValue(state);
};
pp$1.regexp_eatCharacterClass = function(state) {
  if (state.eat(
    91
    /* [ */
  )) {
    state.eat(
      94
      /* ^ */
    );
    this.regexp_classRanges(state);
    if (state.eat(
      93
      /* ] */
    )) {
      return true;
    }
    state.raise("Unterminated character class");
  }
  return false;
};
pp$1.regexp_classRanges = function(state) {
  while (this.regexp_eatClassAtom(state)) {
    var left = state.lastIntValue;
    if (state.eat(
      45
      /* - */
    ) && this.regexp_eatClassAtom(state)) {
      var right = state.lastIntValue;
      if (state.switchU && (left === -1 || right === -1)) {
        state.raise("Invalid character class");
      }
      if (left !== -1 && right !== -1 && left > right) {
        state.raise("Range out of order in character class");
      }
    }
  }
};
pp$1.regexp_eatClassAtom = function(state) {
  var start3 = state.pos;
  if (state.eat(
    92
    /* \ */
  )) {
    if (this.regexp_eatClassEscape(state)) {
      return true;
    }
    if (state.switchU) {
      var ch$1 = state.current();
      if (ch$1 === 99 || isOctalDigit(ch$1)) {
        state.raise("Invalid class escape");
      }
      state.raise("Invalid escape");
    }
    state.pos = start3;
  }
  var ch = state.current();
  if (ch !== 93) {
    state.lastIntValue = ch;
    state.advance();
    return true;
  }
  return false;
};
pp$1.regexp_eatClassEscape = function(state) {
  var start3 = state.pos;
  if (state.eat(
    98
    /* b */
  )) {
    state.lastIntValue = 8;
    return true;
  }
  if (state.switchU && state.eat(
    45
    /* - */
  )) {
    state.lastIntValue = 45;
    return true;
  }
  if (!state.switchU && state.eat(
    99
    /* c */
  )) {
    if (this.regexp_eatClassControlLetter(state)) {
      return true;
    }
    state.pos = start3;
  }
  return this.regexp_eatCharacterClassEscape(state) || this.regexp_eatCharacterEscape(state);
};
pp$1.regexp_eatClassControlLetter = function(state) {
  var ch = state.current();
  if (isDecimalDigit(ch) || ch === 95) {
    state.lastIntValue = ch % 32;
    state.advance();
    return true;
  }
  return false;
};
pp$1.regexp_eatHexEscapeSequence = function(state) {
  var start3 = state.pos;
  if (state.eat(
    120
    /* x */
  )) {
    if (this.regexp_eatFixedHexDigits(state, 2)) {
      return true;
    }
    if (state.switchU) {
      state.raise("Invalid escape");
    }
    state.pos = start3;
  }
  return false;
};
pp$1.regexp_eatDecimalDigits = function(state) {
  var start3 = state.pos;
  var ch = 0;
  state.lastIntValue = 0;
  while (isDecimalDigit(ch = state.current())) {
    state.lastIntValue = 10 * state.lastIntValue + (ch - 48);
    state.advance();
  }
  return state.pos !== start3;
};
function isDecimalDigit(ch) {
  return ch >= 48 && ch <= 57;
}
pp$1.regexp_eatHexDigits = function(state) {
  var start3 = state.pos;
  var ch = 0;
  state.lastIntValue = 0;
  while (isHexDigit(ch = state.current())) {
    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
    state.advance();
  }
  return state.pos !== start3;
};
function isHexDigit(ch) {
  return ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102;
}
function hexToInt(ch) {
  if (ch >= 65 && ch <= 70) {
    return 10 + (ch - 65);
  }
  if (ch >= 97 && ch <= 102) {
    return 10 + (ch - 97);
  }
  return ch - 48;
}
pp$1.regexp_eatLegacyOctalEscapeSequence = function(state) {
  if (this.regexp_eatOctalDigit(state)) {
    var n1 = state.lastIntValue;
    if (this.regexp_eatOctalDigit(state)) {
      var n2 = state.lastIntValue;
      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
      } else {
        state.lastIntValue = n1 * 8 + n2;
      }
    } else {
      state.lastIntValue = n1;
    }
    return true;
  }
  return false;
};
pp$1.regexp_eatOctalDigit = function(state) {
  var ch = state.current();
  if (isOctalDigit(ch)) {
    state.lastIntValue = ch - 48;
    state.advance();
    return true;
  }
  state.lastIntValue = 0;
  return false;
};
function isOctalDigit(ch) {
  return ch >= 48 && ch <= 55;
}
pp$1.regexp_eatFixedHexDigits = function(state, length) {
  var start3 = state.pos;
  state.lastIntValue = 0;
  for (var i = 0; i < length; ++i) {
    var ch = state.current();
    if (!isHexDigit(ch)) {
      state.pos = start3;
      return false;
    }
    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
    state.advance();
  }
  return true;
};
var Token = function Token2(p) {
  this.type = p.type;
  this.value = p.value;
  this.start = p.start;
  this.end = p.end;
  if (p.options.locations) {
    this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
  }
  if (p.options.ranges) {
    this.range = [p.start, p.end];
  }
};
var pp = Parser.prototype;
pp.next = function(ignoreEscapeSequenceInKeyword) {
  if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc) {
    this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword);
  }
  if (this.options.onToken) {
    this.options.onToken(new Token(this));
  }
  this.lastTokEnd = this.end;
  this.lastTokStart = this.start;
  this.lastTokEndLoc = this.endLoc;
  this.lastTokStartLoc = this.startLoc;
  this.nextToken();
};
pp.getToken = function() {
  this.next();
  return new Token(this);
};
if (typeof Symbol !== "undefined") {
  pp[Symbol.iterator] = function() {
    var this$1$1 = this;
    return {
      next: function() {
        var token2 = this$1$1.getToken();
        return {
          done: token2.type === types$1.eof,
          value: token2
        };
      }
    };
  };
}
pp.nextToken = function() {
  var curContext = this.curContext();
  if (!curContext || !curContext.preserveSpace) {
    this.skipSpace();
  }
  this.start = this.pos;
  if (this.options.locations) {
    this.startLoc = this.curPosition();
  }
  if (this.pos >= this.input.length) {
    return this.finishToken(types$1.eof);
  }
  if (curContext.override) {
    return curContext.override(this);
  } else {
    this.readToken(this.fullCharCodeAtPos());
  }
};
pp.readToken = function(code2) {
  if (isIdentifierStart(code2, this.options.ecmaVersion >= 6) || code2 === 92) {
    return this.readWord();
  }
  return this.getTokenFromCode(code2);
};
pp.fullCharCodeAtPos = function() {
  var code2 = this.input.charCodeAt(this.pos);
  if (code2 <= 55295 || code2 >= 56320) {
    return code2;
  }
  var next = this.input.charCodeAt(this.pos + 1);
  return next <= 56319 || next >= 57344 ? code2 : (code2 << 10) + next - 56613888;
};
pp.skipBlockComment = function() {
  var startLoc = this.options.onComment && this.curPosition();
  var start3 = this.pos, end = this.input.indexOf("*/", this.pos += 2);
  if (end === -1) {
    this.raise(this.pos - 2, "Unterminated comment");
  }
  this.pos = end + 2;
  if (this.options.locations) {
    for (var nextBreak = void 0, pos2 = start3; (nextBreak = nextLineBreak(this.input, pos2, this.pos)) > -1; ) {
      ++this.curLine;
      pos2 = this.lineStart = nextBreak;
    }
  }
  if (this.options.onComment) {
    this.options.onComment(
      true,
      this.input.slice(start3 + 2, end),
      start3,
      this.pos,
      startLoc,
      this.curPosition()
    );
  }
};
pp.skipLineComment = function(startSkip) {
  var start3 = this.pos;
  var startLoc = this.options.onComment && this.curPosition();
  var ch = this.input.charCodeAt(this.pos += startSkip);
  while (this.pos < this.input.length && !isNewLine(ch)) {
    ch = this.input.charCodeAt(++this.pos);
  }
  if (this.options.onComment) {
    this.options.onComment(
      false,
      this.input.slice(start3 + startSkip, this.pos),
      start3,
      this.pos,
      startLoc,
      this.curPosition()
    );
  }
};
pp.skipSpace = function() {
  loop:
    while (this.pos < this.input.length) {
      var ch = this.input.charCodeAt(this.pos);
      switch (ch) {
        case 32:
        case 160:
          ++this.pos;
          break;
        case 13:
          if (this.input.charCodeAt(this.pos + 1) === 10) {
            ++this.pos;
          }
        case 10:
        case 8232:
        case 8233:
          ++this.pos;
          if (this.options.locations) {
            ++this.curLine;
            this.lineStart = this.pos;
          }
          break;
        case 47:
          switch (this.input.charCodeAt(this.pos + 1)) {
            case 42:
              this.skipBlockComment();
              break;
            case 47:
              this.skipLineComment(2);
              break;
            default:
              break loop;
          }
          break;
        default:
          if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
            ++this.pos;
          } else {
            break loop;
          }
      }
    }
};
pp.finishToken = function(type, val) {
  this.end = this.pos;
  if (this.options.locations) {
    this.endLoc = this.curPosition();
  }
  var prevType = this.type;
  this.type = type;
  this.value = val;
  this.updateContext(prevType);
};
pp.readToken_dot = function() {
  var next = this.input.charCodeAt(this.pos + 1);
  if (next >= 48 && next <= 57) {
    return this.readNumber(true);
  }
  var next2 = this.input.charCodeAt(this.pos + 2);
  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {
    this.pos += 3;
    return this.finishToken(types$1.ellipsis);
  } else {
    ++this.pos;
    return this.finishToken(types$1.dot);
  }
};
pp.readToken_slash = function() {
  var next = this.input.charCodeAt(this.pos + 1);
  if (this.exprAllowed) {
    ++this.pos;
    return this.readRegexp();
  }
  if (next === 61) {
    return this.finishOp(types$1.assign, 2);
  }
  return this.finishOp(types$1.slash, 1);
};
pp.readToken_mult_modulo_exp = function(code2) {
  var next = this.input.charCodeAt(this.pos + 1);
  var size = 1;
  var tokentype = code2 === 42 ? types$1.star : types$1.modulo;
  if (this.options.ecmaVersion >= 7 && code2 === 42 && next === 42) {
    ++size;
    tokentype = types$1.starstar;
    next = this.input.charCodeAt(this.pos + 2);
  }
  if (next === 61) {
    return this.finishOp(types$1.assign, size + 1);
  }
  return this.finishOp(tokentype, size);
};
pp.readToken_pipe_amp = function(code2) {
  var next = this.input.charCodeAt(this.pos + 1);
  if (next === code2) {
    if (this.options.ecmaVersion >= 12) {
      var next2 = this.input.charCodeAt(this.pos + 2);
      if (next2 === 61) {
        return this.finishOp(types$1.assign, 3);
      }
    }
    return this.finishOp(code2 === 124 ? types$1.logicalOR : types$1.logicalAND, 2);
  }
  if (next === 61) {
    return this.finishOp(types$1.assign, 2);
  }
  return this.finishOp(code2 === 124 ? types$1.bitwiseOR : types$1.bitwiseAND, 1);
};
pp.readToken_caret = function() {
  var next = this.input.charCodeAt(this.pos + 1);
  if (next === 61) {
    return this.finishOp(types$1.assign, 2);
  }
  return this.finishOp(types$1.bitwiseXOR, 1);
};
pp.readToken_plus_min = function(code2) {
  var next = this.input.charCodeAt(this.pos + 1);
  if (next === code2) {
    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 && (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
      this.skipLineComment(3);
      this.skipSpace();
      return this.nextToken();
    }
    return this.finishOp(types$1.incDec, 2);
  }
  if (next === 61) {
    return this.finishOp(types$1.assign, 2);
  }
  return this.finishOp(types$1.plusMin, 1);
};
pp.readToken_lt_gt = function(code2) {
  var next = this.input.charCodeAt(this.pos + 1);
  var size = 1;
  if (next === code2) {
    size = code2 === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
    if (this.input.charCodeAt(this.pos + size) === 61) {
      return this.finishOp(types$1.assign, size + 1);
    }
    return this.finishOp(types$1.bitShift, size);
  }
  if (next === 33 && code2 === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 && this.input.charCodeAt(this.pos + 3) === 45) {
    this.skipLineComment(4);
    this.skipSpace();
    return this.nextToken();
  }
  if (next === 61) {
    size = 2;
  }
  return this.finishOp(types$1.relational, size);
};
pp.readToken_eq_excl = function(code2) {
  var next = this.input.charCodeAt(this.pos + 1);
  if (next === 61) {
    return this.finishOp(types$1.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
  }
  if (code2 === 61 && next === 62 && this.options.ecmaVersion >= 6) {
    this.pos += 2;
    return this.finishToken(types$1.arrow);
  }
  return this.finishOp(code2 === 61 ? types$1.eq : types$1.prefix, 1);
};
pp.readToken_question = function() {
  var ecmaVersion = this.options.ecmaVersion;
  if (ecmaVersion >= 11) {
    var next = this.input.charCodeAt(this.pos + 1);
    if (next === 46) {
      var next2 = this.input.charCodeAt(this.pos + 2);
      if (next2 < 48 || next2 > 57) {
        return this.finishOp(types$1.questionDot, 2);
      }
    }
    if (next === 63) {
      if (ecmaVersion >= 12) {
        var next2$1 = this.input.charCodeAt(this.pos + 2);
        if (next2$1 === 61) {
          return this.finishOp(types$1.assign, 3);
        }
      }
      return this.finishOp(types$1.coalesce, 2);
    }
  }
  return this.finishOp(types$1.question, 1);
};
pp.readToken_numberSign = function() {
  var ecmaVersion = this.options.ecmaVersion;
  var code2 = 35;
  if (ecmaVersion >= 13) {
    ++this.pos;
    code2 = this.fullCharCodeAtPos();
    if (isIdentifierStart(code2, true) || code2 === 92) {
      return this.finishToken(types$1.privateId, this.readWord1());
    }
  }
  this.raise(this.pos, "Unexpected character '" + codePointToString(code2) + "'");
};
pp.getTokenFromCode = function(code2) {
  switch (code2) {
    case 46:
      return this.readToken_dot();
    case 40:
      ++this.pos;
      return this.finishToken(types$1.parenL);
    case 41:
      ++this.pos;
      return this.finishToken(types$1.parenR);
    case 59:
      ++this.pos;
      return this.finishToken(types$1.semi);
    case 44:
      ++this.pos;
      return this.finishToken(types$1.comma);
    case 91:
      ++this.pos;
      return this.finishToken(types$1.bracketL);
    case 93:
      ++this.pos;
      return this.finishToken(types$1.bracketR);
    case 123:
      ++this.pos;
      return this.finishToken(types$1.braceL);
    case 125:
      ++this.pos;
      return this.finishToken(types$1.braceR);
    case 58:
      ++this.pos;
      return this.finishToken(types$1.colon);
    case 96:
      if (this.options.ecmaVersion < 6) {
        break;
      }
      ++this.pos;
      return this.finishToken(types$1.backQuote);
    case 48:
      var next = this.input.charCodeAt(this.pos + 1);
      if (next === 120 || next === 88) {
        return this.readRadixNumber(16);
      }
      if (this.options.ecmaVersion >= 6) {
        if (next === 111 || next === 79) {
          return this.readRadixNumber(8);
        }
        if (next === 98 || next === 66) {
          return this.readRadixNumber(2);
        }
      }
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
      return this.readNumber(false);
    case 34:
    case 39:
      return this.readString(code2);
    case 47:
      return this.readToken_slash();
    case 37:
    case 42:
      return this.readToken_mult_modulo_exp(code2);
    case 124:
    case 38:
      return this.readToken_pipe_amp(code2);
    case 94:
      return this.readToken_caret();
    case 43:
    case 45:
      return this.readToken_plus_min(code2);
    case 60:
    case 62:
      return this.readToken_lt_gt(code2);
    case 61:
    case 33:
      return this.readToken_eq_excl(code2);
    case 63:
      return this.readToken_question();
    case 126:
      return this.finishOp(types$1.prefix, 1);
    case 35:
      return this.readToken_numberSign();
  }
  this.raise(this.pos, "Unexpected character '" + codePointToString(code2) + "'");
};
pp.finishOp = function(type, size) {
  var str = this.input.slice(this.pos, this.pos + size);
  this.pos += size;
  return this.finishToken(type, str);
};
pp.readRegexp = function() {
  var escaped, inClass, start3 = this.pos;
  for (; ; ) {
    if (this.pos >= this.input.length) {
      this.raise(start3, "Unterminated regular expression");
    }
    var ch = this.input.charAt(this.pos);
    if (lineBreak.test(ch)) {
      this.raise(start3, "Unterminated regular expression");
    }
    if (!escaped) {
      if (ch === "[") {
        inClass = true;
      } else if (ch === "]" && inClass) {
        inClass = false;
      } else if (ch === "/" && !inClass) {
        break;
      }
      escaped = ch === "\\";
    } else {
      escaped = false;
    }
    ++this.pos;
  }
  var pattern = this.input.slice(start3, this.pos);
  ++this.pos;
  var flagsStart = this.pos;
  var flags = this.readWord1();
  if (this.containsEsc) {
    this.unexpected(flagsStart);
  }
  var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
  state.reset(start3, pattern, flags);
  this.validateRegExpFlags(state);
  this.validateRegExpPattern(state);
  var value2 = null;
  try {
    value2 = new RegExp(pattern, flags);
  } catch (e) {
  }
  return this.finishToken(types$1.regexp, { pattern, flags, value: value2 });
};
pp.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
  var allowSeparators = this.options.ecmaVersion >= 12 && len === void 0;
  var isLegacyOctalNumericLiteral = maybeLegacyOctalNumericLiteral && this.input.charCodeAt(this.pos) === 48;
  var start3 = this.pos, total = 0, lastCode = 0;
  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i, ++this.pos) {
    var code2 = this.input.charCodeAt(this.pos), val = void 0;
    if (allowSeparators && code2 === 95) {
      if (isLegacyOctalNumericLiteral) {
        this.raiseRecoverable(this.pos, "Numeric separator is not allowed in legacy octal numeric literals");
      }
      if (lastCode === 95) {
        this.raiseRecoverable(this.pos, "Numeric separator must be exactly one underscore");
      }
      if (i === 0) {
        this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits");
      }
      lastCode = code2;
      continue;
    }
    if (code2 >= 97) {
      val = code2 - 97 + 10;
    } else if (code2 >= 65) {
      val = code2 - 65 + 10;
    } else if (code2 >= 48 && code2 <= 57) {
      val = code2 - 48;
    } else {
      val = Infinity;
    }
    if (val >= radix) {
      break;
    }
    lastCode = code2;
    total = total * radix + val;
  }
  if (allowSeparators && lastCode === 95) {
    this.raiseRecoverable(this.pos - 1, "Numeric separator is not allowed at the last of digits");
  }
  if (this.pos === start3 || len != null && this.pos - start3 !== len) {
    return null;
  }
  return total;
};
function stringToNumber(str, isLegacyOctalNumericLiteral) {
  if (isLegacyOctalNumericLiteral) {
    return parseInt(str, 8);
  }
  return parseFloat(str.replace(/_/g, ""));
}
function stringToBigInt(str) {
  if (typeof BigInt !== "function") {
    return null;
  }
  return BigInt(str.replace(/_/g, ""));
}
pp.readRadixNumber = function(radix) {
  var start3 = this.pos;
  this.pos += 2;
  var val = this.readInt(radix);
  if (val == null) {
    this.raise(this.start + 2, "Expected number in radix " + radix);
  }
  if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
    val = stringToBigInt(this.input.slice(start3, this.pos));
    ++this.pos;
  } else if (isIdentifierStart(this.fullCharCodeAtPos())) {
    this.raise(this.pos, "Identifier directly after number");
  }
  return this.finishToken(types$1.num, val);
};
pp.readNumber = function(startsWithDot) {
  var start3 = this.pos;
  if (!startsWithDot && this.readInt(10, void 0, true) === null) {
    this.raise(start3, "Invalid number");
  }
  var octal = this.pos - start3 >= 2 && this.input.charCodeAt(start3) === 48;
  if (octal && this.strict) {
    this.raise(start3, "Invalid number");
  }
  var next = this.input.charCodeAt(this.pos);
  if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
    var val$1 = stringToBigInt(this.input.slice(start3, this.pos));
    ++this.pos;
    if (isIdentifierStart(this.fullCharCodeAtPos())) {
      this.raise(this.pos, "Identifier directly after number");
    }
    return this.finishToken(types$1.num, val$1);
  }
  if (octal && /[89]/.test(this.input.slice(start3, this.pos))) {
    octal = false;
  }
  if (next === 46 && !octal) {
    ++this.pos;
    this.readInt(10);
    next = this.input.charCodeAt(this.pos);
  }
  if ((next === 69 || next === 101) && !octal) {
    next = this.input.charCodeAt(++this.pos);
    if (next === 43 || next === 45) {
      ++this.pos;
    }
    if (this.readInt(10) === null) {
      this.raise(start3, "Invalid number");
    }
  }
  if (isIdentifierStart(this.fullCharCodeAtPos())) {
    this.raise(this.pos, "Identifier directly after number");
  }
  var val = stringToNumber(this.input.slice(start3, this.pos), octal);
  return this.finishToken(types$1.num, val);
};
pp.readCodePoint = function() {
  var ch = this.input.charCodeAt(this.pos), code2;
  if (ch === 123) {
    if (this.options.ecmaVersion < 6) {
      this.unexpected();
    }
    var codePos = ++this.pos;
    code2 = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
    ++this.pos;
    if (code2 > 1114111) {
      this.invalidStringToken(codePos, "Code point out of bounds");
    }
  } else {
    code2 = this.readHexChar(4);
  }
  return code2;
};
pp.readString = function(quote) {
  var out = "", chunkStart = ++this.pos;
  for (; ; ) {
    if (this.pos >= this.input.length) {
      this.raise(this.start, "Unterminated string constant");
    }
    var ch = this.input.charCodeAt(this.pos);
    if (ch === quote) {
      break;
    }
    if (ch === 92) {
      out += this.input.slice(chunkStart, this.pos);
      out += this.readEscapedChar(false);
      chunkStart = this.pos;
    } else if (ch === 8232 || ch === 8233) {
      if (this.options.ecmaVersion < 10) {
        this.raise(this.start, "Unterminated string constant");
      }
      ++this.pos;
      if (this.options.locations) {
        this.curLine++;
        this.lineStart = this.pos;
      }
    } else {
      if (isNewLine(ch)) {
        this.raise(this.start, "Unterminated string constant");
      }
      ++this.pos;
    }
  }
  out += this.input.slice(chunkStart, this.pos++);
  return this.finishToken(types$1.string, out);
};
var INVALID_TEMPLATE_ESCAPE_ERROR = {};
pp.tryReadTemplateToken = function() {
  this.inTemplateElement = true;
  try {
    this.readTmplToken();
  } catch (err) {
    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
      this.readInvalidTemplateToken();
    } else {
      throw err;
    }
  }
  this.inTemplateElement = false;
};
pp.invalidStringToken = function(position3, message) {
  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
    throw INVALID_TEMPLATE_ESCAPE_ERROR;
  } else {
    this.raise(position3, message);
  }
};
pp.readTmplToken = function() {
  var out = "", chunkStart = this.pos;
  for (; ; ) {
    if (this.pos >= this.input.length) {
      this.raise(this.start, "Unterminated template");
    }
    var ch = this.input.charCodeAt(this.pos);
    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) {
      if (this.pos === this.start && (this.type === types$1.template || this.type === types$1.invalidTemplate)) {
        if (ch === 36) {
          this.pos += 2;
          return this.finishToken(types$1.dollarBraceL);
        } else {
          ++this.pos;
          return this.finishToken(types$1.backQuote);
        }
      }
      out += this.input.slice(chunkStart, this.pos);
      return this.finishToken(types$1.template, out);
    }
    if (ch === 92) {
      out += this.input.slice(chunkStart, this.pos);
      out += this.readEscapedChar(true);
      chunkStart = this.pos;
    } else if (isNewLine(ch)) {
      out += this.input.slice(chunkStart, this.pos);
      ++this.pos;
      switch (ch) {
        case 13:
          if (this.input.charCodeAt(this.pos) === 10) {
            ++this.pos;
          }
        case 10:
          out += "\n";
          break;
        default:
          out += String.fromCharCode(ch);
          break;
      }
      if (this.options.locations) {
        ++this.curLine;
        this.lineStart = this.pos;
      }
      chunkStart = this.pos;
    } else {
      ++this.pos;
    }
  }
};
pp.readInvalidTemplateToken = function() {
  for (; this.pos < this.input.length; this.pos++) {
    switch (this.input[this.pos]) {
      case "\\":
        ++this.pos;
        break;
      case "$":
        if (this.input[this.pos + 1] !== "{") {
          break;
        }
      case "`":
        return this.finishToken(types$1.invalidTemplate, this.input.slice(this.start, this.pos));
    }
  }
  this.raise(this.start, "Unterminated template");
};
pp.readEscapedChar = function(inTemplate) {
  var ch = this.input.charCodeAt(++this.pos);
  ++this.pos;
  switch (ch) {
    case 110:
      return "\n";
    case 114:
      return "\r";
    case 120:
      return String.fromCharCode(this.readHexChar(2));
    case 117:
      return codePointToString(this.readCodePoint());
    case 116:
      return "	";
    case 98:
      return "\b";
    case 118:
      return "\v";
    case 102:
      return "\f";
    case 13:
      if (this.input.charCodeAt(this.pos) === 10) {
        ++this.pos;
      }
    case 10:
      if (this.options.locations) {
        this.lineStart = this.pos;
        ++this.curLine;
      }
      return "";
    case 56:
    case 57:
      if (this.strict) {
        this.invalidStringToken(
          this.pos - 1,
          "Invalid escape sequence"
        );
      }
      if (inTemplate) {
        var codePos = this.pos - 1;
        this.invalidStringToken(
          codePos,
          "Invalid escape sequence in template string"
        );
      }
    default:
      if (ch >= 48 && ch <= 55) {
        var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
        var octal = parseInt(octalStr, 8);
        if (octal > 255) {
          octalStr = octalStr.slice(0, -1);
          octal = parseInt(octalStr, 8);
        }
        this.pos += octalStr.length - 1;
        ch = this.input.charCodeAt(this.pos);
        if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
          this.invalidStringToken(
            this.pos - 1 - octalStr.length,
            inTemplate ? "Octal literal in template string" : "Octal literal in strict mode"
          );
        }
        return String.fromCharCode(octal);
      }
      if (isNewLine(ch)) {
        return "";
      }
      return String.fromCharCode(ch);
  }
};
pp.readHexChar = function(len) {
  var codePos = this.pos;
  var n = this.readInt(16, len);
  if (n === null) {
    this.invalidStringToken(codePos, "Bad character escape sequence");
  }
  return n;
};
pp.readWord1 = function() {
  this.containsEsc = false;
  var word = "", first = true, chunkStart = this.pos;
  var astral = this.options.ecmaVersion >= 6;
  while (this.pos < this.input.length) {
    var ch = this.fullCharCodeAtPos();
    if (isIdentifierChar(ch, astral)) {
      this.pos += ch <= 65535 ? 1 : 2;
    } else if (ch === 92) {
      this.containsEsc = true;
      word += this.input.slice(chunkStart, this.pos);
      var escStart = this.pos;
      if (this.input.charCodeAt(++this.pos) !== 117) {
        this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX");
      }
      ++this.pos;
      var esc = this.readCodePoint();
      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral)) {
        this.invalidStringToken(escStart, "Invalid Unicode escape");
      }
      word += codePointToString(esc);
      chunkStart = this.pos;
    } else {
      break;
    }
    first = false;
  }
  return word + this.input.slice(chunkStart, this.pos);
};
pp.readWord = function() {
  var word = this.readWord1();
  var type = types$1.name;
  if (this.keywords.test(word)) {
    type = keywords[word];
  }
  return this.finishToken(type, word);
};
var version = "8.8.2";
Parser.acorn = {
  Parser,
  version,
  defaultOptions,
  Position,
  SourceLocation,
  getLineInfo,
  Node,
  TokenType,
  tokTypes: types$1,
  keywordTypes: keywords,
  TokContext,
  tokContexts: types,
  isIdentifierChar,
  isIdentifierStart,
  Token,
  isNewLine,
  lineBreak,
  lineBreakG,
  nonASCIIwhitespace
};

// node_modules/micromark-extension-mdxjs/index.js
var import_acorn_jsx = __toESM(require_acorn_jsx(), 1);

// node_modules/micromark-util-chunked/index.js
function splice(list3, start3, remove, items) {
  const end = list3.length;
  let chunkStart = 0;
  let parameters;
  if (start3 < 0) {
    start3 = -start3 > end ? 0 : end + start3;
  } else {
    start3 = start3 > end ? end : start3;
  }
  remove = remove > 0 ? remove : 0;
  if (items.length < 1e4) {
    parameters = Array.from(items);
    parameters.unshift(start3, remove);
    [].splice.apply(list3, parameters);
  } else {
    if (remove)
      [].splice.apply(list3, [start3, remove]);
    while (chunkStart < items.length) {
      parameters = items.slice(chunkStart, chunkStart + 1e4);
      parameters.unshift(start3, 0);
      [].splice.apply(list3, parameters);
      chunkStart += 1e4;
      start3 += 1e4;
    }
  }
}
function push(list3, items) {
  if (list3.length > 0) {
    splice(list3, list3.length, 0, items);
    return list3;
  }
  return items;
}

// node_modules/micromark-util-combine-extensions/index.js
var hasOwnProperty3 = {}.hasOwnProperty;
function combineExtensions(extensions) {
  const all4 = {};
  let index2 = -1;
  while (++index2 < extensions.length) {
    syntaxExtension(all4, extensions[index2]);
  }
  return all4;
}
function syntaxExtension(all4, extension2) {
  let hook;
  for (hook in extension2) {
    const maybe = hasOwnProperty3.call(all4, hook) ? all4[hook] : void 0;
    const left = maybe || (all4[hook] = {});
    const right = extension2[hook];
    let code2;
    for (code2 in right) {
      if (!hasOwnProperty3.call(left, code2))
        left[code2] = [];
      const value2 = right[code2];
      constructs(
        // @ts-expect-error Looks like a list.
        left[code2],
        Array.isArray(value2) ? value2 : value2 ? [value2] : []
      );
    }
  }
}
function constructs(existing, list3) {
  let index2 = -1;
  const before = [];
  while (++index2 < list3.length) {
    ;
    (list3[index2].add === "after" ? existing : before).push(list3[index2]);
  }
  splice(existing, 0, 0, before);
}

// node_modules/micromark-util-character/lib/unicode-punctuation-regex.js
var unicodePunctuationRegex = /[!-/:-@[-`{-~\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;

// node_modules/micromark-util-character/index.js
var asciiAlpha = regexCheck(/[A-Za-z]/);
var asciiDigit = regexCheck(/\d/);
var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
function asciiControl(code2) {
  return (
    // Special whitespace codes (which have negative values), C0 and Control
    // character DEL
    code2 !== null && (code2 < 32 || code2 === 127)
  );
}
function markdownLineEndingOrSpace(code2) {
  return code2 !== null && (code2 < 0 || code2 === 32);
}
function markdownLineEnding(code2) {
  return code2 !== null && code2 < -2;
}
function markdownSpace(code2) {
  return code2 === -2 || code2 === -1 || code2 === 32;
}
var unicodeWhitespace = regexCheck(/\s/);
var unicodePunctuation = regexCheck(unicodePunctuationRegex);
function regexCheck(regex2) {
  return check;
  function check(code2) {
    return code2 !== null && regex2.test(String.fromCharCode(code2));
  }
}

// node_modules/micromark-factory-space/index.js
function factorySpace(effects, ok2, type, max) {
  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
  let size = 0;
  return start3;
  function start3(code2) {
    if (markdownSpace(code2)) {
      effects.enter(type);
      return prefix(code2);
    }
    return ok2(code2);
  }
  function prefix(code2) {
    if (markdownSpace(code2) && size++ < limit) {
      effects.consume(code2);
      return prefix;
    }
    effects.exit(type);
    return ok2(code2);
  }
}

// node_modules/unist-util-position-from-estree/lib/index.js
function positionFromEstree(node2) {
  const nodeLike = node2 || {};
  const loc = nodeLike.loc || {};
  const range = nodeLike.range || [0, 0];
  const startColumn = loc.start ? numberOrUndefined(loc.start.column) : void 0;
  const endColumn = loc.end ? numberOrUndefined(loc.end.column) : void 0;
  return {
    start: {
      // @ts-expect-error: return no point / no position next major.
      line: loc.start ? numberOrUndefined(loc.start.line) : void 0,
      // @ts-expect-error: return no point / no position next major.
      column: startColumn === void 0 ? void 0 : startColumn + 1,
      offset: numberOrUndefined(range[0] || nodeLike.start)
    },
    end: {
      // @ts-expect-error: return no point / no position next major.
      line: loc.end ? numberOrUndefined(loc.end.line) : void 0,
      // @ts-expect-error: return no point / no position next major.
      column: endColumn === void 0 ? void 0 : endColumn + 1,
      offset: numberOrUndefined(range[1] || nodeLike.end)
    }
  };
}
function numberOrUndefined(value2) {
  return typeof value2 === "number" && value2 > -1 ? value2 : void 0;
}

// node_modules/estree-util-visit/lib/color.js
function color(d) {
  return "\x1B[33m" + d + "\x1B[39m";
}

// node_modules/estree-util-visit/lib/index.js
var own2 = {}.hasOwnProperty;
var CONTINUE = Symbol("continue");
var EXIT = Symbol("exit");
var SKIP = Symbol("skip");
function visit(tree, visitor) {
  let enter;
  let leave;
  if (typeof visitor === "function") {
    enter = visitor;
  } else if (visitor && typeof visitor === "object") {
    if (visitor.enter)
      enter = visitor.enter;
    if (visitor.leave)
      leave = visitor.leave;
  }
  build(tree, null, null, [])();
  function build(node2, key2, index2, parents) {
    if (nodelike(node2)) {
      visit3.displayName = "node (" + color(node2.type) + ")";
    }
    return visit3;
    function visit3() {
      const result = enter ? toResult(enter(node2, key2, index2, parents)) : [];
      if (result[0] === EXIT) {
        return result;
      }
      if (result[0] !== SKIP) {
        let cKey;
        for (cKey in node2) {
          if (own2.call(node2, cKey) && node2[cKey] && typeof node2[cKey] === "object" && // @ts-expect-error: custom esast extension.
          cKey !== "data" && // @ts-expect-error: custom esast extension.
          cKey !== "position") {
            const grandparents = parents.concat(node2);
            const value2 = node2[cKey];
            if (Array.isArray(value2)) {
              const nodes = (
                /** @type {Array<unknown>} */
                value2
              );
              let cIndex = 0;
              while (cIndex > -1 && cIndex < nodes.length) {
                const subvalue = nodes[cIndex];
                if (nodelike(subvalue)) {
                  const subresult = build(
                    subvalue,
                    cKey,
                    cIndex,
                    grandparents
                  )();
                  if (subresult[0] === EXIT)
                    return subresult;
                  cIndex = typeof subresult[1] === "number" ? subresult[1] : cIndex + 1;
                } else {
                  cIndex++;
                }
              }
            } else if (nodelike(value2)) {
              const subresult = build(value2, cKey, null, grandparents)();
              if (subresult[0] === EXIT)
                return subresult;
            }
          }
        }
      }
      return leave ? toResult(leave(node2, key2, index2, parents)) : result;
    }
  }
}
function toResult(value2) {
  if (Array.isArray(value2)) {
    return value2;
  }
  if (typeof value2 === "number") {
    return [CONTINUE, value2];
  }
  return [value2];
}
function nodelike(value2) {
  return Boolean(
    value2 && typeof value2 === "object" && "type" in value2 && typeof value2.type === "string" && value2.type.length > 0
  );
}

// node_modules/vfile-location/lib/index.js
function location(file) {
  const value2 = String(file);
  const indices = [];
  const search2 = /\r?\n|\r/g;
  while (search2.test(value2)) {
    indices.push(search2.lastIndex);
  }
  indices.push(value2.length + 1);
  return { toPoint, toOffset };
  function toPoint(offset3) {
    let index2 = -1;
    if (typeof offset3 === "number" && offset3 > -1 && offset3 < indices[indices.length - 1]) {
      while (++index2 < indices.length) {
        if (indices[index2] > offset3) {
          return {
            line: index2 + 1,
            column: offset3 - (index2 > 0 ? indices[index2 - 1] : 0) + 1,
            offset: offset3
          };
        }
      }
    }
    return { line: void 0, column: void 0, offset: void 0 };
  }
  function toOffset(point4) {
    const line2 = point4 && point4.line;
    const column2 = point4 && point4.column;
    if (typeof line2 === "number" && typeof column2 === "number" && !Number.isNaN(line2) && !Number.isNaN(column2) && line2 - 1 in indices) {
      const offset3 = (indices[line2 - 2] || 0) + column2 - 1 || 0;
      if (offset3 > -1 && offset3 < indices[indices.length - 1]) {
        return offset3;
      }
    }
    return -1;
  }
}

// node_modules/micromark-util-events-to-acorn/index.js
function eventsToAcorn(events, options) {
  const prefix = options.prefix || "";
  const suffix = options.suffix || "";
  const acornOptions = Object.assign({}, options.acornOptions);
  const comments = [];
  const tokens = [];
  const onComment = acornOptions.onComment;
  const onToken = acornOptions.onToken;
  const chunks = [];
  const lines = {};
  let index2 = -1;
  let swallow = false;
  let estree;
  let exception;
  let startLine;
  const acornConfig = Object.assign({}, acornOptions, {
    onComment: comments,
    preserveParens: true
  });
  if (onToken) {
    acornConfig.onToken = tokens;
  }
  if (options.start) {
    startLine = options.start.line;
    lines[startLine] = options.start;
  }
  while (++index2 < events.length) {
    const [kind, token2, context] = events[index2];
    if (kind === "exit") {
      chunks.push(context.sliceSerialize(token2));
      setPoint(token2.start);
      setPoint(token2.end);
    }
  }
  const source2 = chunks.join("");
  const value2 = prefix + source2 + suffix;
  const isEmptyExpression = options.expression && empty3(source2);
  const place = location(source2);
  if (isEmptyExpression && !options.allowEmpty) {
    throw new VFileMessage("Unexpected empty expression", parseOffsetToUnistPoint(0), "micromark-extension-mdx-expression:unexpected-empty-expression");
  }
  try {
    estree = options.expression && !isEmptyExpression ? options.acorn.parseExpressionAt(value2, 0, acornConfig) : options.acorn.parse(value2, acornConfig);
  } catch (error_) {
    const error = (
      /** @type {AcornError} */
      error_
    );
    const point4 = parseOffsetToUnistPoint(error.pos);
    error.message = String(error.message).replace(/ \(\d+:\d+\)$/, "");
    error.pos = point4.offset;
    error.loc = {
      line: point4.line,
      column: point4.column - 1
    };
    exception = error;
    swallow = error.raisedAt >= prefix.length + source2.length || // Broken comments are raised at their start, not their end.
    error.message === "Unterminated comment";
  }
  if (estree && options.expression && !isEmptyExpression) {
    if (empty3(value2.slice(estree.end, value2.length - suffix.length))) {
      estree = {
        type: "Program",
        start: 0,
        end: prefix.length + source2.length,
        // @ts-expect-error: It’s good.
        body: [{
          type: "ExpressionStatement",
          expression: estree,
          start: 0,
          end: prefix.length + source2.length
        }],
        sourceType: "module",
        comments: []
      };
    } else {
      const point4 = parseOffsetToUnistPoint(estree.end);
      exception = new Error("Unexpected content after expression");
      exception.pos = point4.offset;
      exception.loc = {
        line: point4.line,
        column: point4.column - 1
      };
      estree = void 0;
    }
  }
  if (estree) {
    estree.comments = comments;
    visit(estree, (esnode, field, index3, parents) => {
      let context = (
        /** @type {AcornNode | Array<AcornNode>} */
        parents[parents.length - 1]
      );
      let prop = field;
      if (esnode.type === "ParenthesizedExpression" && context && prop) {
        if (typeof index3 === "number") {
          context = context[prop];
          prop = index3;
        }
        context[prop] = esnode.expression;
      }
      fixPosition(esnode);
    });
    if (Array.isArray(onComment)) {
      onComment.push(...comments);
    } else if (typeof onComment === "function") {
      for (const comment2 of comments) {
        onComment(comment2.type === "Block", comment2.value, comment2.start, comment2.end, comment2.loc.start, comment2.loc.end);
      }
    }
    for (const token2 of tokens) {
      fixPosition(token2);
      if (Array.isArray(onToken)) {
        onToken.push(token2);
      } else {
        onToken(token2);
      }
    }
  }
  return {
    estree,
    error: exception,
    swallow
  };
  function fixPosition(nodeOrToken) {
    const pointStart2 = parseOffsetToUnistPoint(nodeOrToken.start);
    const pointEnd2 = parseOffsetToUnistPoint(nodeOrToken.end);
    nodeOrToken.start = pointStart2.offset;
    nodeOrToken.end = pointEnd2.offset;
    nodeOrToken.loc = {
      start: {
        line: pointStart2.line,
        column: pointStart2.column - 1,
        offset: pointStart2.offset
      },
      end: {
        line: pointEnd2.line,
        column: pointEnd2.column - 1,
        offset: pointEnd2.offset
      }
    };
    nodeOrToken.range = [nodeOrToken.start, nodeOrToken.end];
  }
  function parseOffsetToUnistPoint(acornOffset) {
    let sourceOffset = acornOffset - prefix.length;
    if (sourceOffset < 0) {
      sourceOffset = 0;
    } else if (sourceOffset > source2.length) {
      sourceOffset = source2.length;
    }
    const pointInSource = place.toPoint(sourceOffset);
    const line2 = startLine + (pointInSource.line - 1);
    const column2 = lines[line2].column + (pointInSource.column - 1);
    const offset3 = lines[line2].offset + (pointInSource.column - 1);
    return (
      /** @type {Point} */
      {
        line: line2,
        column: column2,
        offset: offset3
      }
    );
  }
  function setPoint(point4) {
    if (!startLine || point4.line < startLine) {
      startLine = point4.line;
    }
    if (!(point4.line in lines) || lines[point4.line].offset > point4.offset) {
      lines[point4.line] = point4;
    }
  }
}
function empty3(value2) {
  return /^\s*$/.test(value2.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\r\n]*(\r\n|\n|\r)/g, ""));
}

// node_modules/micromark-factory-mdx-expression/index.js
function factoryMdxExpression(effects, ok2, type, markerType, chunkType, acorn, acornOptions, addResult, spread, allowEmpty, allowLazy, startColumn) {
  const self2 = this;
  const eventStart = this.events.length + 3;
  const tail = this.events[this.events.length - 1];
  const initialPrefix = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
  const prefixExpressionIndent = initialPrefix ? initialPrefix + 1 : 0;
  let balance = 1;
  let startPosition;
  let lastCrash;
  return start3;
  function start3(code2) {
    effects.enter(type);
    effects.enter(markerType);
    effects.consume(code2);
    effects.exit(markerType);
    startPosition = self2.now();
    return atBreak;
  }
  function atBreak(code2) {
    if (code2 === null) {
      throw lastCrash || new VFileMessage(
        "Unexpected end of file in expression, expected a corresponding closing brace for `{`",
        self2.now(),
        "micromark-extension-mdx-expression:unexpected-eof"
      );
    }
    if (code2 === 125) {
      return atClosingBrace(code2);
    }
    if (markdownLineEnding(code2)) {
      effects.enter("lineEnding");
      effects.consume(code2);
      effects.exit("lineEnding");
      const prefixTagIndent = startColumn ? startColumn + 4 - self2.now().column : 0;
      const indent = Math.max(prefixExpressionIndent, prefixTagIndent);
      return indent ? factorySpace(effects, atBreak, "linePrefix", indent) : atBreak;
    }
    const now = self2.now();
    if (now.line !== startPosition.line && !allowLazy && self2.parser.lazy[now.line]) {
      throw new VFileMessage(
        "Unexpected end of file in expression, expected a corresponding closing brace for `{`",
        self2.now(),
        "micromark-extension-mdx-expression:unexpected-eof"
      );
    }
    effects.enter(chunkType);
    return inside(code2);
  }
  function inside(code2) {
    if (code2 === null || code2 === 125 || markdownLineEnding(code2)) {
      effects.exit(chunkType);
      return atBreak(code2);
    }
    if (code2 === 123 && !acorn) {
      effects.consume(code2);
      balance++;
      return inside;
    }
    effects.consume(code2);
    return inside;
  }
  function atClosingBrace(code2) {
    balance--;
    if (!acorn) {
      if (balance) {
        effects.enter(chunkType);
        effects.consume(code2);
        return inside;
      }
      effects.enter(markerType);
      effects.consume(code2);
      effects.exit(markerType);
      effects.exit(type);
      return ok2;
    }
    const result = eventsToAcorn(self2.events.slice(eventStart), {
      acorn,
      acornOptions,
      start: startPosition,
      expression: true,
      allowEmpty,
      prefix: spread ? "({" : "",
      suffix: spread ? "})" : ""
    });
    const estree = result.estree;
    if (spread && estree) {
      const head = estree.body[0];
      if (head.type !== "ExpressionStatement" || head.expression.type !== "ObjectExpression") {
        throw new VFileMessage(
          "Unexpected `" + head.type + "` in code: expected an object spread (`{...spread}`)",
          positionFromEstree(head).start,
          "micromark-extension-mdx-expression:non-spread"
        );
      } else if (head.expression.properties[1]) {
        throw new VFileMessage(
          "Unexpected extra content in spread: only a single spread is supported",
          positionFromEstree(head.expression.properties[1]).start,
          "micromark-extension-mdx-expression:spread-extra"
        );
      } else if (head.expression.properties[0] && head.expression.properties[0].type !== "SpreadElement") {
        throw new VFileMessage(
          "Unexpected `" + head.expression.properties[0].type + "` in code: only spread elements are supported",
          positionFromEstree(head.expression.properties[0]).start,
          "micromark-extension-mdx-expression:non-spread"
        );
      }
    }
    if (result.error) {
      lastCrash = new VFileMessage(
        "Could not parse expression with acorn: " + result.error.message,
        {
          // @ts-expect-error: fine.
          line: result.error.loc.line,
          // @ts-expect-error: fine.
          column: result.error.loc.column + 1,
          // @ts-expect-error: fine.
          offset: result.error.pos
        },
        "micromark-extension-mdx-expression:acorn"
      );
      if (code2 !== null && result.swallow) {
        effects.enter(chunkType);
        effects.consume(code2);
        return inside;
      }
      throw lastCrash;
    }
    effects.enter(markerType);
    effects.consume(code2);
    effects.exit(markerType);
    Object.assign(
      effects.exit(type),
      addResult ? {
        estree
      } : void 0
    );
    return ok2;
  }
}

// node_modules/micromark-extension-mdx-expression/lib/syntax.js
function mdxExpression(options) {
  const options_ = options || {};
  const addResult = options_.addResult;
  const acorn = options_.acorn;
  const spread = options_.spread;
  let allowEmpty = options_.allowEmpty;
  let acornOptions;
  if (allowEmpty === null || allowEmpty === void 0) {
    allowEmpty = true;
  }
  if (acorn) {
    if (!acorn.parseExpressionAt) {
      throw new Error(
        "Expected a proper `acorn` instance passed in as `options.acorn`"
      );
    }
    acornOptions = Object.assign(
      {
        ecmaVersion: 2020,
        sourceType: "module"
      },
      options_.acornOptions
    );
  } else if (options_.acornOptions || options_.addResult) {
    throw new Error("Expected an `acorn` instance passed in as `options.acorn`");
  }
  return {
    flow: {
      [123]: {
        tokenize: tokenizeFlowExpression,
        concrete: true
      }
    },
    text: {
      [123]: {
        tokenize: tokenizeTextExpression
      }
    }
  };
  function tokenizeFlowExpression(effects, ok2, nok) {
    const self2 = this;
    return start3;
    function start3(code2) {
      return factoryMdxExpression.call(
        self2,
        effects,
        factorySpace(effects, after, "whitespace"),
        "mdxFlowExpression",
        "mdxFlowExpressionMarker",
        "mdxFlowExpressionChunk",
        acorn,
        acornOptions,
        addResult,
        spread,
        allowEmpty
      )(code2);
    }
    function after(code2) {
      return code2 === null || markdownLineEnding(code2) ? ok2(code2) : nok(code2);
    }
  }
  function tokenizeTextExpression(effects, ok2) {
    const self2 = this;
    return start3;
    function start3(code2) {
      return factoryMdxExpression.call(
        self2,
        effects,
        ok2,
        "mdxTextExpression",
        "mdxTextExpressionMarker",
        "mdxTextExpressionChunk",
        acorn,
        acornOptions,
        addResult,
        spread,
        allowEmpty,
        true
      )(code2);
    }
  }
}

// node_modules/estree-util-is-identifier-name/lib/regex.js
var start = /[$A-Z_a-z\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/;
var cont = /[\d\u00B7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F]/;

// node_modules/estree-util-is-identifier-name/lib/index.js
function start2(code2) {
  return start.test(String.fromCharCode(code2));
}
function cont2(code2) {
  const character = String.fromCharCode(code2);
  return start.test(character) || cont.test(character);
}
function name(name2) {
  let index2 = -1;
  while (++index2 < name2.length) {
    if (!(index2 ? cont2 : start2)(name2.charCodeAt(index2)))
      return false;
  }
  return index2 > 0;
}

// node_modules/micromark-extension-mdx-jsx/lib/factory-tag.js
var lazyLineEnd = {
  tokenize: tokenizeLazyLineEnd,
  partial: true
};
function factoryTag(effects, ok2, nok, acorn, acornOptions, addResult, allowLazy, tagType, tagMarkerType, tagClosingMarkerType, tagSelfClosingMarker, tagNameType, tagNamePrimaryType, tagNameMemberMarkerType, tagNameMemberType, tagNamePrefixMarkerType, tagNameLocalType, tagExpressionAttributeType, tagExpressionAttributeMarkerType, tagExpressionAttributeValueType, tagAttributeType, tagAttributeNameType, tagAttributeNamePrimaryType, tagAttributeNamePrefixMarkerType, tagAttributeNameLocalType, tagAttributeInitializerMarkerType, tagAttributeValueLiteralType, tagAttributeValueLiteralMarkerType, tagAttributeValueLiteralValueType, tagAttributeValueExpressionType, tagAttributeValueExpressionMarkerType, tagAttributeValueExpressionValueType) {
  const self2 = this;
  let returnState;
  let marker;
  let startPoint;
  return start3;
  function start3(code2) {
    startPoint = self2.now();
    effects.enter(tagType);
    effects.enter(tagMarkerType);
    effects.consume(code2);
    effects.exit(tagMarkerType);
    return afterStart;
  }
  function afterStart(code2) {
    if (markdownLineEnding(code2) || markdownSpace(code2)) {
      return nok(code2);
    }
    returnState = beforeName;
    return optionalEsWhitespace(code2);
  }
  function beforeName(code2) {
    if (code2 === 47) {
      effects.enter(tagClosingMarkerType);
      effects.consume(code2);
      effects.exit(tagClosingMarkerType);
      returnState = beforeClosingTagName;
      return optionalEsWhitespace;
    }
    if (code2 === 62) {
      return tagEnd(code2);
    }
    if (code2 !== null && start2(code2)) {
      effects.enter(tagNameType);
      effects.enter(tagNamePrimaryType);
      effects.consume(code2);
      return primaryName;
    }
    crash(
      code2,
      "before name",
      "a character that can start a name, such as a letter, `$`, or `_`" + (code2 === 33 ? " (note: to create a comment in MDX, use `{/* text */}`)" : "")
    );
  }
  function beforeClosingTagName(code2) {
    if (code2 === 62) {
      return tagEnd(code2);
    }
    if (code2 !== null && start2(code2)) {
      effects.enter(tagNameType);
      effects.enter(tagNamePrimaryType);
      effects.consume(code2);
      return primaryName;
    }
    crash(
      code2,
      "before name",
      "a character that can start a name, such as a letter, `$`, or `_`" + (code2 === 42 || code2 === 47 ? " (note: JS comments in JSX tags are not supported in MDX)" : "")
    );
  }
  function primaryName(code2) {
    if (code2 === 45 || code2 !== null && cont2(code2)) {
      effects.consume(code2);
      return primaryName;
    }
    if (code2 === 46 || code2 === 47 || code2 === 58 || code2 === 62 || code2 === 123 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
      effects.exit(tagNamePrimaryType);
      returnState = afterPrimaryName;
      return optionalEsWhitespace(code2);
    }
    crash(
      code2,
      "in name",
      "a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag" + (code2 === 64 ? " (note: to create a link in MDX, use `[text](url)`)" : "")
    );
  }
  function afterPrimaryName(code2) {
    if (code2 === 46) {
      effects.enter(tagNameMemberMarkerType);
      effects.consume(code2);
      effects.exit(tagNameMemberMarkerType);
      returnState = beforeMemberName;
      return optionalEsWhitespace;
    }
    if (code2 === 58) {
      effects.enter(tagNamePrefixMarkerType);
      effects.consume(code2);
      effects.exit(tagNamePrefixMarkerType);
      returnState = beforeLocalName;
      return optionalEsWhitespace;
    }
    if (code2 === 47 || code2 === 62 || code2 === 123 || code2 !== null && start2(code2)) {
      effects.exit(tagNameType);
      return beforeAttribute(code2);
    }
    crash(
      code2,
      "after name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag"
    );
  }
  function beforeMemberName(code2) {
    if (code2 !== null && start2(code2)) {
      effects.enter(tagNameMemberType);
      effects.consume(code2);
      return memberName;
    }
    crash(
      code2,
      "before member name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag"
    );
  }
  function memberName(code2) {
    if (code2 === 45 || code2 !== null && cont2(code2)) {
      effects.consume(code2);
      return memberName;
    }
    if (code2 === 46 || code2 === 47 || code2 === 62 || code2 === 123 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
      effects.exit(tagNameMemberType);
      returnState = afterMemberName;
      return optionalEsWhitespace(code2);
    }
    crash(
      code2,
      "in member name",
      "a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag" + (code2 === 64 ? " (note: to create a link in MDX, use `[text](url)`)" : "")
    );
  }
  function afterMemberName(code2) {
    if (code2 === 46) {
      effects.enter(tagNameMemberMarkerType);
      effects.consume(code2);
      effects.exit(tagNameMemberMarkerType);
      returnState = beforeMemberName;
      return optionalEsWhitespace;
    }
    if (code2 === 47 || code2 === 62 || code2 === 123 || code2 !== null && start2(code2)) {
      effects.exit(tagNameType);
      return beforeAttribute(code2);
    }
    crash(
      code2,
      "after member name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag"
    );
  }
  function beforeLocalName(code2) {
    if (code2 !== null && start2(code2)) {
      effects.enter(tagNameLocalType);
      effects.consume(code2);
      return localName;
    }
    crash(
      code2,
      "before local name",
      "a character that can start a name, such as a letter, `$`, or `_`" + (code2 === 43 || code2 !== null && code2 > 46 && code2 < 58 ? (
        /* `/` - `9` */
        " (note: to create a link in MDX, use `[text](url)`)"
      ) : "")
    );
  }
  function localName(code2) {
    if (code2 === 45 || code2 !== null && cont2(code2)) {
      effects.consume(code2);
      return localName;
    }
    if (code2 === 47 || code2 === 62 || code2 === 123 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
      effects.exit(tagNameLocalType);
      returnState = afterLocalName;
      return optionalEsWhitespace(code2);
    }
    crash(
      code2,
      "in local name",
      "a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag"
    );
  }
  function afterLocalName(code2) {
    if (code2 === 47 || code2 === 62 || code2 === 123 || code2 !== null && start2(code2)) {
      effects.exit(tagNameType);
      return beforeAttribute(code2);
    }
    crash(
      code2,
      "after local name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag"
    );
  }
  function beforeAttribute(code2) {
    if (code2 === 47) {
      effects.enter(tagSelfClosingMarker);
      effects.consume(code2);
      effects.exit(tagSelfClosingMarker);
      returnState = selfClosing;
      return optionalEsWhitespace;
    }
    if (code2 === 62) {
      return tagEnd(code2);
    }
    if (code2 === 123) {
      return factoryMdxExpression.call(
        self2,
        effects,
        afterAttributeExpression,
        tagExpressionAttributeType,
        tagExpressionAttributeMarkerType,
        tagExpressionAttributeValueType,
        acorn,
        acornOptions,
        addResult,
        true,
        false,
        allowLazy,
        startPoint.column
      )(code2);
    }
    if (code2 !== null && start2(code2)) {
      effects.enter(tagAttributeType);
      effects.enter(tagAttributeNameType);
      effects.enter(tagAttributeNamePrimaryType);
      effects.consume(code2);
      return attributePrimaryName;
    }
    crash(
      code2,
      "before attribute name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag"
    );
  }
  function afterAttributeExpression(code2) {
    returnState = beforeAttribute;
    return optionalEsWhitespace(code2);
  }
  function attributePrimaryName(code2) {
    if (code2 === 45 || code2 !== null && cont2(code2)) {
      effects.consume(code2);
      return attributePrimaryName;
    }
    if (code2 === 47 || code2 === 58 || code2 === 61 || code2 === 62 || code2 === 123 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
      effects.exit(tagAttributeNamePrimaryType);
      returnState = afterAttributePrimaryName;
      return optionalEsWhitespace(code2);
    }
    crash(
      code2,
      "in attribute name",
      "an attribute name character such as letters, digits, `$`, or `_`; `=` to initialize a value; whitespace before attributes; or the end of the tag"
    );
  }
  function afterAttributePrimaryName(code2) {
    if (code2 === 58) {
      effects.enter(tagAttributeNamePrefixMarkerType);
      effects.consume(code2);
      effects.exit(tagAttributeNamePrefixMarkerType);
      returnState = beforeAttributeLocalName;
      return optionalEsWhitespace;
    }
    if (code2 === 61) {
      effects.exit(tagAttributeNameType);
      effects.enter(tagAttributeInitializerMarkerType);
      effects.consume(code2);
      effects.exit(tagAttributeInitializerMarkerType);
      returnState = beforeAttributeValue;
      return optionalEsWhitespace;
    }
    if (code2 === 47 || code2 === 62 || code2 === 123 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2) || code2 !== null && start2(code2)) {
      effects.exit(tagAttributeNameType);
      effects.exit(tagAttributeType);
      returnState = beforeAttribute;
      return optionalEsWhitespace(code2);
    }
    crash(
      code2,
      "after attribute name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag"
    );
  }
  function beforeAttributeLocalName(code2) {
    if (code2 !== null && start2(code2)) {
      effects.enter(tagAttributeNameLocalType);
      effects.consume(code2);
      return attributeLocalName;
    }
    crash(
      code2,
      "before local attribute name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag"
    );
  }
  function attributeLocalName(code2) {
    if (code2 === 45 || code2 !== null && cont2(code2)) {
      effects.consume(code2);
      return attributeLocalName;
    }
    if (code2 === 47 || code2 === 61 || code2 === 62 || code2 === 123 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
      effects.exit(tagAttributeNameLocalType);
      effects.exit(tagAttributeNameType);
      returnState = afterAttributeLocalName;
      return optionalEsWhitespace(code2);
    }
    crash(
      code2,
      "in local attribute name",
      "an attribute name character such as letters, digits, `$`, or `_`; `=` to initialize a value; whitespace before attributes; or the end of the tag"
    );
  }
  function afterAttributeLocalName(code2) {
    if (code2 === 61) {
      effects.enter(tagAttributeInitializerMarkerType);
      effects.consume(code2);
      effects.exit(tagAttributeInitializerMarkerType);
      returnState = beforeAttributeValue;
      return optionalEsWhitespace;
    }
    if (code2 === 47 || code2 === 62 || code2 === 123 || code2 !== null && start2(code2)) {
      effects.exit(tagAttributeType);
      return beforeAttribute(code2);
    }
    crash(
      code2,
      "after local attribute name",
      "a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag"
    );
  }
  function beforeAttributeValue(code2) {
    if (code2 === 34 || code2 === 39) {
      effects.enter(tagAttributeValueLiteralType);
      effects.enter(tagAttributeValueLiteralMarkerType);
      effects.consume(code2);
      effects.exit(tagAttributeValueLiteralMarkerType);
      marker = code2;
      return attributeValueQuotedStart;
    }
    if (code2 === 123) {
      return factoryMdxExpression.call(
        self2,
        effects,
        afterAttributeValueExpression,
        tagAttributeValueExpressionType,
        tagAttributeValueExpressionMarkerType,
        tagAttributeValueExpressionValueType,
        acorn,
        acornOptions,
        addResult,
        false,
        false,
        allowLazy,
        startPoint.column
      )(code2);
    }
    crash(
      code2,
      "before attribute value",
      "a character that can start an attribute value, such as `\"`, `'`, or `{`" + (code2 === 60 ? " (note: to use an element or fragment as a prop value in MDX, use `{<element />}`)" : "")
    );
  }
  function afterAttributeValueExpression(code2) {
    effects.exit(tagAttributeType);
    returnState = beforeAttribute;
    return optionalEsWhitespace(code2);
  }
  function attributeValueQuotedStart(code2) {
    if (code2 === null) {
      crash(
        code2,
        "in attribute value",
        "a corresponding closing quote `" + String.fromCharCode(marker) + "`"
      );
    }
    if (code2 === marker) {
      effects.enter(tagAttributeValueLiteralMarkerType);
      effects.consume(code2);
      effects.exit(tagAttributeValueLiteralMarkerType);
      effects.exit(tagAttributeValueLiteralType);
      effects.exit(tagAttributeType);
      marker = void 0;
      returnState = beforeAttribute;
      return optionalEsWhitespace;
    }
    if (markdownLineEnding(code2)) {
      returnState = attributeValueQuotedStart;
      return optionalEsWhitespace(code2);
    }
    effects.enter(tagAttributeValueLiteralValueType);
    return attributeValueQuoted(code2);
  }
  function attributeValueQuoted(code2) {
    if (code2 === null || code2 === marker || markdownLineEnding(code2)) {
      effects.exit(tagAttributeValueLiteralValueType);
      return attributeValueQuotedStart(code2);
    }
    effects.consume(code2);
    return attributeValueQuoted;
  }
  function selfClosing(code2) {
    if (code2 === 62) {
      return tagEnd(code2);
    }
    crash(
      code2,
      "after self-closing slash",
      "`>` to end the tag" + (code2 === 42 || code2 === 47 ? " (note: JS comments in JSX tags are not supported in MDX)" : "")
    );
  }
  function tagEnd(code2) {
    effects.enter(tagMarkerType);
    effects.consume(code2);
    effects.exit(tagMarkerType);
    effects.exit(tagType);
    return ok2;
  }
  function optionalEsWhitespace(code2) {
    if (markdownLineEnding(code2)) {
      if (allowLazy) {
        effects.enter("lineEnding");
        effects.consume(code2);
        effects.exit("lineEnding");
        return factorySpace(effects, optionalEsWhitespace, "linePrefix", 4);
      }
      return effects.attempt(
        lazyLineEnd,
        factorySpace(effects, optionalEsWhitespace, "linePrefix", 4),
        crashEol
      )(code2);
    }
    if (markdownSpace(code2) || unicodeWhitespace(code2)) {
      effects.enter("esWhitespace");
      return optionalEsWhitespaceContinue(code2);
    }
    return returnState(code2);
  }
  function optionalEsWhitespaceContinue(code2) {
    if (markdownLineEnding(code2) || !(markdownSpace(code2) || unicodeWhitespace(code2))) {
      effects.exit("esWhitespace");
      return optionalEsWhitespace(code2);
    }
    effects.consume(code2);
    return optionalEsWhitespaceContinue;
  }
  function crashEol() {
    throw new VFileMessage(
      "Unexpected lazy line in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
      self2.now(),
      "micromark-extension-mdx-jsx:unexpected-eof"
    );
  }
  function crash(code2, at3, expect) {
    throw new VFileMessage(
      "Unexpected " + (code2 === null ? "end of file" : "character `" + (code2 === 96 ? "` ` `" : String.fromCharCode(code2)) + "` (" + serializeCharCode(code2) + ")") + " " + at3 + ", expected " + expect,
      self2.now(),
      "micromark-extension-mdx-jsx:unexpected-" + (code2 === null ? "eof" : "character")
    );
  }
}
function tokenizeLazyLineEnd(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    effects.enter("lineEnding");
    effects.consume(code2);
    effects.exit("lineEnding");
    return lineStart;
  }
  function lineStart(code2) {
    return self2.parser.lazy[self2.now().line] ? nok(code2) : ok2(code2);
  }
}
function serializeCharCode(code2) {
  return "U+" + code2.toString(16).toUpperCase().padStart(4, "0");
}

// node_modules/micromark-extension-mdx-jsx/lib/jsx-text.js
function jsxText(acorn, acornOptions, addResult) {
  return {
    tokenize: tokenizeJsxText
  };
  function tokenizeJsxText(effects, ok2, nok) {
    return factoryTag.call(
      this,
      effects,
      ok2,
      nok,
      acorn,
      acornOptions,
      addResult,
      true,
      "mdxJsxTextTag",
      "mdxJsxTextTagMarker",
      "mdxJsxTextTagClosingMarker",
      "mdxJsxTextTagSelfClosingMarker",
      "mdxJsxTextTagName",
      "mdxJsxTextTagNamePrimary",
      "mdxJsxTextTagNameMemberMarker",
      "mdxJsxTextTagNameMember",
      "mdxJsxTextTagNamePrefixMarker",
      "mdxJsxTextTagNameLocal",
      "mdxJsxTextTagExpressionAttribute",
      "mdxJsxTextTagExpressionAttributeMarker",
      "mdxJsxTextTagExpressionAttributeValue",
      "mdxJsxTextTagAttribute",
      "mdxJsxTextTagAttributeName",
      "mdxJsxTextTagAttributeNamePrimary",
      "mdxJsxTextTagAttributeNamePrefixMarker",
      "mdxJsxTextTagAttributeNameLocal",
      "mdxJsxTextTagAttributeInitializerMarker",
      "mdxJsxTextTagAttributeValueLiteral",
      "mdxJsxTextTagAttributeValueLiteralMarker",
      "mdxJsxTextTagAttributeValueLiteralValue",
      "mdxJsxTextTagAttributeValueExpression",
      "mdxJsxTextTagAttributeValueExpressionMarker",
      "mdxJsxTextTagAttributeValueExpressionValue"
    );
  }
}

// node_modules/micromark-extension-mdx-jsx/lib/jsx-flow.js
function jsxFlow(acorn, acornOptions, addResult) {
  return {
    tokenize: tokenizeJsxFlow,
    concrete: true
  };
  function tokenizeJsxFlow(effects, ok2, nok) {
    const self2 = this;
    return start3;
    function start3(code2) {
      return factoryTag.call(
        self2,
        effects,
        factorySpace(effects, after, "whitespace"),
        nok,
        acorn,
        acornOptions,
        addResult,
        false,
        "mdxJsxFlowTag",
        "mdxJsxFlowTagMarker",
        "mdxJsxFlowTagClosingMarker",
        "mdxJsxFlowTagSelfClosingMarker",
        "mdxJsxFlowTagName",
        "mdxJsxFlowTagNamePrimary",
        "mdxJsxFlowTagNameMemberMarker",
        "mdxJsxFlowTagNameMember",
        "mdxJsxFlowTagNamePrefixMarker",
        "mdxJsxFlowTagNameLocal",
        "mdxJsxFlowTagExpressionAttribute",
        "mdxJsxFlowTagExpressionAttributeMarker",
        "mdxJsxFlowTagExpressionAttributeValue",
        "mdxJsxFlowTagAttribute",
        "mdxJsxFlowTagAttributeName",
        "mdxJsxFlowTagAttributeNamePrimary",
        "mdxJsxFlowTagAttributeNamePrefixMarker",
        "mdxJsxFlowTagAttributeNameLocal",
        "mdxJsxFlowTagAttributeInitializerMarker",
        "mdxJsxFlowTagAttributeValueLiteral",
        "mdxJsxFlowTagAttributeValueLiteralMarker",
        "mdxJsxFlowTagAttributeValueLiteralValue",
        "mdxJsxFlowTagAttributeValueExpression",
        "mdxJsxFlowTagAttributeValueExpressionMarker",
        "mdxJsxFlowTagAttributeValueExpressionValue"
      )(code2);
    }
    function after(code2) {
      return code2 === 60 ? start3(code2) : code2 === null || markdownLineEnding(code2) ? ok2(code2) : nok(code2);
    }
  }
}

// node_modules/micromark-extension-mdx-jsx/lib/syntax.js
function mdxJsx(options = {}) {
  const acorn = options.acorn;
  let acornOptions;
  if (acorn) {
    if (!acorn.parse || !acorn.parseExpressionAt) {
      throw new Error(
        "Expected a proper `acorn` instance passed in as `options.acorn`"
      );
    }
    acornOptions = Object.assign(
      {
        ecmaVersion: 2020,
        sourceType: "module"
      },
      options.acornOptions,
      {
        locations: true
      }
    );
  } else if (options.acornOptions || options.addResult) {
    throw new Error("Expected an `acorn` instance passed in as `options.acorn`");
  }
  return {
    flow: {
      [60]: jsxFlow(acorn, acornOptions, options.addResult)
    },
    text: {
      [60]: jsxText(acorn, acornOptions, options.addResult)
    }
  };
}

// node_modules/micromark-extension-mdx-md/index.js
var mdxMd = {
  disable: { null: ["autolink", "codeIndented", "htmlFlow", "htmlText"] }
};

// node_modules/micromark-util-classify-character/index.js
function classifyCharacter(code2) {
  if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
    return 1;
  }
  if (unicodePunctuation(code2)) {
    return 2;
  }
}

// node_modules/micromark-util-resolve-all/index.js
function resolveAll(constructs2, events, context) {
  const called = [];
  let index2 = -1;
  while (++index2 < constructs2.length) {
    const resolve = constructs2[index2].resolveAll;
    if (resolve && !called.includes(resolve)) {
      events = resolve(events, context);
      called.push(resolve);
    }
  }
  return events;
}

// node_modules/micromark-core-commonmark/lib/attention.js
var attention = {
  name: "attention",
  tokenize: tokenizeAttention,
  resolveAll: resolveAllAttention
};
function resolveAllAttention(events, context) {
  let index2 = -1;
  let open;
  let group;
  let text5;
  let openingSequence;
  let closingSequence;
  let use;
  let nextEvents;
  let offset3;
  while (++index2 < events.length) {
    if (events[index2][0] === "enter" && events[index2][1].type === "attentionSequence" && events[index2][1]._close) {
      open = index2;
      while (open--) {
        if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && // If the markers are the same:
        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index2][1]).charCodeAt(0)) {
          if ((events[open][1]._close || events[index2][1]._open) && (events[index2][1].end.offset - events[index2][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index2][1].end.offset - events[index2][1].start.offset) % 3)) {
            continue;
          }
          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index2][1].end.offset - events[index2][1].start.offset > 1 ? 2 : 1;
          const start3 = Object.assign({}, events[open][1].end);
          const end = Object.assign({}, events[index2][1].start);
          movePoint(start3, -use);
          movePoint(end, use);
          openingSequence = {
            type: use > 1 ? "strongSequence" : "emphasisSequence",
            start: start3,
            end: Object.assign({}, events[open][1].end)
          };
          closingSequence = {
            type: use > 1 ? "strongSequence" : "emphasisSequence",
            start: Object.assign({}, events[index2][1].start),
            end
          };
          text5 = {
            type: use > 1 ? "strongText" : "emphasisText",
            start: Object.assign({}, events[open][1].end),
            end: Object.assign({}, events[index2][1].start)
          };
          group = {
            type: use > 1 ? "strong" : "emphasis",
            start: Object.assign({}, openingSequence.start),
            end: Object.assign({}, closingSequence.end)
          };
          events[open][1].end = Object.assign({}, openingSequence.start);
          events[index2][1].start = Object.assign({}, closingSequence.end);
          nextEvents = [];
          if (events[open][1].end.offset - events[open][1].start.offset) {
            nextEvents = push(nextEvents, [
              ["enter", events[open][1], context],
              ["exit", events[open][1], context]
            ]);
          }
          nextEvents = push(nextEvents, [
            ["enter", group, context],
            ["enter", openingSequence, context],
            ["exit", openingSequence, context],
            ["enter", text5, context]
          ]);
          nextEvents = push(
            nextEvents,
            resolveAll(
              context.parser.constructs.insideSpan.null,
              events.slice(open + 1, index2),
              context
            )
          );
          nextEvents = push(nextEvents, [
            ["exit", text5, context],
            ["enter", closingSequence, context],
            ["exit", closingSequence, context],
            ["exit", group, context]
          ]);
          if (events[index2][1].end.offset - events[index2][1].start.offset) {
            offset3 = 2;
            nextEvents = push(nextEvents, [
              ["enter", events[index2][1], context],
              ["exit", events[index2][1], context]
            ]);
          } else {
            offset3 = 0;
          }
          splice(events, open - 1, index2 - open + 3, nextEvents);
          index2 = open + nextEvents.length - offset3 - 2;
          break;
        }
      }
    }
  }
  index2 = -1;
  while (++index2 < events.length) {
    if (events[index2][1].type === "attentionSequence") {
      events[index2][1].type = "data";
    }
  }
  return events;
}
function tokenizeAttention(effects, ok2) {
  const attentionMarkers2 = this.parser.constructs.attentionMarkers.null;
  const previous2 = this.previous;
  const before = classifyCharacter(previous2);
  let marker;
  return start3;
  function start3(code2) {
    effects.enter("attentionSequence");
    marker = code2;
    return sequence(code2);
  }
  function sequence(code2) {
    if (code2 === marker) {
      effects.consume(code2);
      return sequence;
    }
    const token2 = effects.exit("attentionSequence");
    const after = classifyCharacter(code2);
    const open = !after || after === 2 && before || attentionMarkers2.includes(code2);
    const close = !before || before === 2 && after || attentionMarkers2.includes(previous2);
    token2._open = Boolean(marker === 42 ? open : open && (before || !close));
    token2._close = Boolean(marker === 42 ? close : close && (after || !open));
    return ok2(code2);
  }
}
function movePoint(point4, offset3) {
  point4.column += offset3;
  point4.offset += offset3;
  point4._bufferIndex += offset3;
}

// node_modules/micromark-core-commonmark/lib/autolink.js
var autolink = {
  name: "autolink",
  tokenize: tokenizeAutolink
};
function tokenizeAutolink(effects, ok2, nok) {
  let size = 1;
  return start3;
  function start3(code2) {
    effects.enter("autolink");
    effects.enter("autolinkMarker");
    effects.consume(code2);
    effects.exit("autolinkMarker");
    effects.enter("autolinkProtocol");
    return open;
  }
  function open(code2) {
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      return schemeOrEmailAtext;
    }
    return asciiAtext(code2) ? emailAtext(code2) : nok(code2);
  }
  function schemeOrEmailAtext(code2) {
    return code2 === 43 || code2 === 45 || code2 === 46 || asciiAlphanumeric(code2) ? schemeInsideOrEmailAtext(code2) : emailAtext(code2);
  }
  function schemeInsideOrEmailAtext(code2) {
    if (code2 === 58) {
      effects.consume(code2);
      return urlInside;
    }
    if ((code2 === 43 || code2 === 45 || code2 === 46 || asciiAlphanumeric(code2)) && size++ < 32) {
      effects.consume(code2);
      return schemeInsideOrEmailAtext;
    }
    return emailAtext(code2);
  }
  function urlInside(code2) {
    if (code2 === 62) {
      effects.exit("autolinkProtocol");
      return end(code2);
    }
    if (code2 === null || code2 === 32 || code2 === 60 || asciiControl(code2)) {
      return nok(code2);
    }
    effects.consume(code2);
    return urlInside;
  }
  function emailAtext(code2) {
    if (code2 === 64) {
      effects.consume(code2);
      size = 0;
      return emailAtSignOrDot;
    }
    if (asciiAtext(code2)) {
      effects.consume(code2);
      return emailAtext;
    }
    return nok(code2);
  }
  function emailAtSignOrDot(code2) {
    return asciiAlphanumeric(code2) ? emailLabel(code2) : nok(code2);
  }
  function emailLabel(code2) {
    if (code2 === 46) {
      effects.consume(code2);
      size = 0;
      return emailAtSignOrDot;
    }
    if (code2 === 62) {
      effects.exit("autolinkProtocol").type = "autolinkEmail";
      return end(code2);
    }
    return emailValue(code2);
  }
  function emailValue(code2) {
    if ((code2 === 45 || asciiAlphanumeric(code2)) && size++ < 63) {
      effects.consume(code2);
      return code2 === 45 ? emailValue : emailLabel;
    }
    return nok(code2);
  }
  function end(code2) {
    effects.enter("autolinkMarker");
    effects.consume(code2);
    effects.exit("autolinkMarker");
    effects.exit("autolink");
    return ok2;
  }
}

// node_modules/micromark-core-commonmark/lib/blank-line.js
var blankLine = {
  tokenize: tokenizeBlankLine,
  partial: true
};
function tokenizeBlankLine(effects, ok2, nok) {
  return factorySpace(effects, afterWhitespace, "linePrefix");
  function afterWhitespace(code2) {
    return code2 === null || markdownLineEnding(code2) ? ok2(code2) : nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/block-quote.js
var blockQuote = {
  name: "blockQuote",
  tokenize: tokenizeBlockQuoteStart,
  continuation: {
    tokenize: tokenizeBlockQuoteContinuation
  },
  exit
};
function tokenizeBlockQuoteStart(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    if (code2 === 62) {
      const state = self2.containerState;
      if (!state.open) {
        effects.enter("blockQuote", {
          _container: true
        });
        state.open = true;
      }
      effects.enter("blockQuotePrefix");
      effects.enter("blockQuoteMarker");
      effects.consume(code2);
      effects.exit("blockQuoteMarker");
      return after;
    }
    return nok(code2);
  }
  function after(code2) {
    if (markdownSpace(code2)) {
      effects.enter("blockQuotePrefixWhitespace");
      effects.consume(code2);
      effects.exit("blockQuotePrefixWhitespace");
      effects.exit("blockQuotePrefix");
      return ok2;
    }
    effects.exit("blockQuotePrefix");
    return ok2(code2);
  }
}
function tokenizeBlockQuoteContinuation(effects, ok2, nok) {
  return factorySpace(
    effects,
    effects.attempt(blockQuote, ok2, nok),
    "linePrefix",
    this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4
  );
}
function exit(effects) {
  effects.exit("blockQuote");
}

// node_modules/micromark-core-commonmark/lib/character-escape.js
var characterEscape = {
  name: "characterEscape",
  tokenize: tokenizeCharacterEscape
};
function tokenizeCharacterEscape(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    effects.enter("characterEscape");
    effects.enter("escapeMarker");
    effects.consume(code2);
    effects.exit("escapeMarker");
    return open;
  }
  function open(code2) {
    if (asciiPunctuation(code2)) {
      effects.enter("characterEscapeValue");
      effects.consume(code2);
      effects.exit("characterEscapeValue");
      effects.exit("characterEscape");
      return ok2;
    }
    return nok(code2);
  }
}

// node_modules/character-entities/index.js
var characterEntities = {
  AElig: "\xC6",
  AMP: "&",
  Aacute: "\xC1",
  Abreve: "\u0102",
  Acirc: "\xC2",
  Acy: "\u0410",
  Afr: "\u{1D504}",
  Agrave: "\xC0",
  Alpha: "\u0391",
  Amacr: "\u0100",
  And: "\u2A53",
  Aogon: "\u0104",
  Aopf: "\u{1D538}",
  ApplyFunction: "\u2061",
  Aring: "\xC5",
  Ascr: "\u{1D49C}",
  Assign: "\u2254",
  Atilde: "\xC3",
  Auml: "\xC4",
  Backslash: "\u2216",
  Barv: "\u2AE7",
  Barwed: "\u2306",
  Bcy: "\u0411",
  Because: "\u2235",
  Bernoullis: "\u212C",
  Beta: "\u0392",
  Bfr: "\u{1D505}",
  Bopf: "\u{1D539}",
  Breve: "\u02D8",
  Bscr: "\u212C",
  Bumpeq: "\u224E",
  CHcy: "\u0427",
  COPY: "\xA9",
  Cacute: "\u0106",
  Cap: "\u22D2",
  CapitalDifferentialD: "\u2145",
  Cayleys: "\u212D",
  Ccaron: "\u010C",
  Ccedil: "\xC7",
  Ccirc: "\u0108",
  Cconint: "\u2230",
  Cdot: "\u010A",
  Cedilla: "\xB8",
  CenterDot: "\xB7",
  Cfr: "\u212D",
  Chi: "\u03A7",
  CircleDot: "\u2299",
  CircleMinus: "\u2296",
  CirclePlus: "\u2295",
  CircleTimes: "\u2297",
  ClockwiseContourIntegral: "\u2232",
  CloseCurlyDoubleQuote: "\u201D",
  CloseCurlyQuote: "\u2019",
  Colon: "\u2237",
  Colone: "\u2A74",
  Congruent: "\u2261",
  Conint: "\u222F",
  ContourIntegral: "\u222E",
  Copf: "\u2102",
  Coproduct: "\u2210",
  CounterClockwiseContourIntegral: "\u2233",
  Cross: "\u2A2F",
  Cscr: "\u{1D49E}",
  Cup: "\u22D3",
  CupCap: "\u224D",
  DD: "\u2145",
  DDotrahd: "\u2911",
  DJcy: "\u0402",
  DScy: "\u0405",
  DZcy: "\u040F",
  Dagger: "\u2021",
  Darr: "\u21A1",
  Dashv: "\u2AE4",
  Dcaron: "\u010E",
  Dcy: "\u0414",
  Del: "\u2207",
  Delta: "\u0394",
  Dfr: "\u{1D507}",
  DiacriticalAcute: "\xB4",
  DiacriticalDot: "\u02D9",
  DiacriticalDoubleAcute: "\u02DD",
  DiacriticalGrave: "`",
  DiacriticalTilde: "\u02DC",
  Diamond: "\u22C4",
  DifferentialD: "\u2146",
  Dopf: "\u{1D53B}",
  Dot: "\xA8",
  DotDot: "\u20DC",
  DotEqual: "\u2250",
  DoubleContourIntegral: "\u222F",
  DoubleDot: "\xA8",
  DoubleDownArrow: "\u21D3",
  DoubleLeftArrow: "\u21D0",
  DoubleLeftRightArrow: "\u21D4",
  DoubleLeftTee: "\u2AE4",
  DoubleLongLeftArrow: "\u27F8",
  DoubleLongLeftRightArrow: "\u27FA",
  DoubleLongRightArrow: "\u27F9",
  DoubleRightArrow: "\u21D2",
  DoubleRightTee: "\u22A8",
  DoubleUpArrow: "\u21D1",
  DoubleUpDownArrow: "\u21D5",
  DoubleVerticalBar: "\u2225",
  DownArrow: "\u2193",
  DownArrowBar: "\u2913",
  DownArrowUpArrow: "\u21F5",
  DownBreve: "\u0311",
  DownLeftRightVector: "\u2950",
  DownLeftTeeVector: "\u295E",
  DownLeftVector: "\u21BD",
  DownLeftVectorBar: "\u2956",
  DownRightTeeVector: "\u295F",
  DownRightVector: "\u21C1",
  DownRightVectorBar: "\u2957",
  DownTee: "\u22A4",
  DownTeeArrow: "\u21A7",
  Downarrow: "\u21D3",
  Dscr: "\u{1D49F}",
  Dstrok: "\u0110",
  ENG: "\u014A",
  ETH: "\xD0",
  Eacute: "\xC9",
  Ecaron: "\u011A",
  Ecirc: "\xCA",
  Ecy: "\u042D",
  Edot: "\u0116",
  Efr: "\u{1D508}",
  Egrave: "\xC8",
  Element: "\u2208",
  Emacr: "\u0112",
  EmptySmallSquare: "\u25FB",
  EmptyVerySmallSquare: "\u25AB",
  Eogon: "\u0118",
  Eopf: "\u{1D53C}",
  Epsilon: "\u0395",
  Equal: "\u2A75",
  EqualTilde: "\u2242",
  Equilibrium: "\u21CC",
  Escr: "\u2130",
  Esim: "\u2A73",
  Eta: "\u0397",
  Euml: "\xCB",
  Exists: "\u2203",
  ExponentialE: "\u2147",
  Fcy: "\u0424",
  Ffr: "\u{1D509}",
  FilledSmallSquare: "\u25FC",
  FilledVerySmallSquare: "\u25AA",
  Fopf: "\u{1D53D}",
  ForAll: "\u2200",
  Fouriertrf: "\u2131",
  Fscr: "\u2131",
  GJcy: "\u0403",
  GT: ">",
  Gamma: "\u0393",
  Gammad: "\u03DC",
  Gbreve: "\u011E",
  Gcedil: "\u0122",
  Gcirc: "\u011C",
  Gcy: "\u0413",
  Gdot: "\u0120",
  Gfr: "\u{1D50A}",
  Gg: "\u22D9",
  Gopf: "\u{1D53E}",
  GreaterEqual: "\u2265",
  GreaterEqualLess: "\u22DB",
  GreaterFullEqual: "\u2267",
  GreaterGreater: "\u2AA2",
  GreaterLess: "\u2277",
  GreaterSlantEqual: "\u2A7E",
  GreaterTilde: "\u2273",
  Gscr: "\u{1D4A2}",
  Gt: "\u226B",
  HARDcy: "\u042A",
  Hacek: "\u02C7",
  Hat: "^",
  Hcirc: "\u0124",
  Hfr: "\u210C",
  HilbertSpace: "\u210B",
  Hopf: "\u210D",
  HorizontalLine: "\u2500",
  Hscr: "\u210B",
  Hstrok: "\u0126",
  HumpDownHump: "\u224E",
  HumpEqual: "\u224F",
  IEcy: "\u0415",
  IJlig: "\u0132",
  IOcy: "\u0401",
  Iacute: "\xCD",
  Icirc: "\xCE",
  Icy: "\u0418",
  Idot: "\u0130",
  Ifr: "\u2111",
  Igrave: "\xCC",
  Im: "\u2111",
  Imacr: "\u012A",
  ImaginaryI: "\u2148",
  Implies: "\u21D2",
  Int: "\u222C",
  Integral: "\u222B",
  Intersection: "\u22C2",
  InvisibleComma: "\u2063",
  InvisibleTimes: "\u2062",
  Iogon: "\u012E",
  Iopf: "\u{1D540}",
  Iota: "\u0399",
  Iscr: "\u2110",
  Itilde: "\u0128",
  Iukcy: "\u0406",
  Iuml: "\xCF",
  Jcirc: "\u0134",
  Jcy: "\u0419",
  Jfr: "\u{1D50D}",
  Jopf: "\u{1D541}",
  Jscr: "\u{1D4A5}",
  Jsercy: "\u0408",
  Jukcy: "\u0404",
  KHcy: "\u0425",
  KJcy: "\u040C",
  Kappa: "\u039A",
  Kcedil: "\u0136",
  Kcy: "\u041A",
  Kfr: "\u{1D50E}",
  Kopf: "\u{1D542}",
  Kscr: "\u{1D4A6}",
  LJcy: "\u0409",
  LT: "<",
  Lacute: "\u0139",
  Lambda: "\u039B",
  Lang: "\u27EA",
  Laplacetrf: "\u2112",
  Larr: "\u219E",
  Lcaron: "\u013D",
  Lcedil: "\u013B",
  Lcy: "\u041B",
  LeftAngleBracket: "\u27E8",
  LeftArrow: "\u2190",
  LeftArrowBar: "\u21E4",
  LeftArrowRightArrow: "\u21C6",
  LeftCeiling: "\u2308",
  LeftDoubleBracket: "\u27E6",
  LeftDownTeeVector: "\u2961",
  LeftDownVector: "\u21C3",
  LeftDownVectorBar: "\u2959",
  LeftFloor: "\u230A",
  LeftRightArrow: "\u2194",
  LeftRightVector: "\u294E",
  LeftTee: "\u22A3",
  LeftTeeArrow: "\u21A4",
  LeftTeeVector: "\u295A",
  LeftTriangle: "\u22B2",
  LeftTriangleBar: "\u29CF",
  LeftTriangleEqual: "\u22B4",
  LeftUpDownVector: "\u2951",
  LeftUpTeeVector: "\u2960",
  LeftUpVector: "\u21BF",
  LeftUpVectorBar: "\u2958",
  LeftVector: "\u21BC",
  LeftVectorBar: "\u2952",
  Leftarrow: "\u21D0",
  Leftrightarrow: "\u21D4",
  LessEqualGreater: "\u22DA",
  LessFullEqual: "\u2266",
  LessGreater: "\u2276",
  LessLess: "\u2AA1",
  LessSlantEqual: "\u2A7D",
  LessTilde: "\u2272",
  Lfr: "\u{1D50F}",
  Ll: "\u22D8",
  Lleftarrow: "\u21DA",
  Lmidot: "\u013F",
  LongLeftArrow: "\u27F5",
  LongLeftRightArrow: "\u27F7",
  LongRightArrow: "\u27F6",
  Longleftarrow: "\u27F8",
  Longleftrightarrow: "\u27FA",
  Longrightarrow: "\u27F9",
  Lopf: "\u{1D543}",
  LowerLeftArrow: "\u2199",
  LowerRightArrow: "\u2198",
  Lscr: "\u2112",
  Lsh: "\u21B0",
  Lstrok: "\u0141",
  Lt: "\u226A",
  Map: "\u2905",
  Mcy: "\u041C",
  MediumSpace: "\u205F",
  Mellintrf: "\u2133",
  Mfr: "\u{1D510}",
  MinusPlus: "\u2213",
  Mopf: "\u{1D544}",
  Mscr: "\u2133",
  Mu: "\u039C",
  NJcy: "\u040A",
  Nacute: "\u0143",
  Ncaron: "\u0147",
  Ncedil: "\u0145",
  Ncy: "\u041D",
  NegativeMediumSpace: "\u200B",
  NegativeThickSpace: "\u200B",
  NegativeThinSpace: "\u200B",
  NegativeVeryThinSpace: "\u200B",
  NestedGreaterGreater: "\u226B",
  NestedLessLess: "\u226A",
  NewLine: "\n",
  Nfr: "\u{1D511}",
  NoBreak: "\u2060",
  NonBreakingSpace: "\xA0",
  Nopf: "\u2115",
  Not: "\u2AEC",
  NotCongruent: "\u2262",
  NotCupCap: "\u226D",
  NotDoubleVerticalBar: "\u2226",
  NotElement: "\u2209",
  NotEqual: "\u2260",
  NotEqualTilde: "\u2242\u0338",
  NotExists: "\u2204",
  NotGreater: "\u226F",
  NotGreaterEqual: "\u2271",
  NotGreaterFullEqual: "\u2267\u0338",
  NotGreaterGreater: "\u226B\u0338",
  NotGreaterLess: "\u2279",
  NotGreaterSlantEqual: "\u2A7E\u0338",
  NotGreaterTilde: "\u2275",
  NotHumpDownHump: "\u224E\u0338",
  NotHumpEqual: "\u224F\u0338",
  NotLeftTriangle: "\u22EA",
  NotLeftTriangleBar: "\u29CF\u0338",
  NotLeftTriangleEqual: "\u22EC",
  NotLess: "\u226E",
  NotLessEqual: "\u2270",
  NotLessGreater: "\u2278",
  NotLessLess: "\u226A\u0338",
  NotLessSlantEqual: "\u2A7D\u0338",
  NotLessTilde: "\u2274",
  NotNestedGreaterGreater: "\u2AA2\u0338",
  NotNestedLessLess: "\u2AA1\u0338",
  NotPrecedes: "\u2280",
  NotPrecedesEqual: "\u2AAF\u0338",
  NotPrecedesSlantEqual: "\u22E0",
  NotReverseElement: "\u220C",
  NotRightTriangle: "\u22EB",
  NotRightTriangleBar: "\u29D0\u0338",
  NotRightTriangleEqual: "\u22ED",
  NotSquareSubset: "\u228F\u0338",
  NotSquareSubsetEqual: "\u22E2",
  NotSquareSuperset: "\u2290\u0338",
  NotSquareSupersetEqual: "\u22E3",
  NotSubset: "\u2282\u20D2",
  NotSubsetEqual: "\u2288",
  NotSucceeds: "\u2281",
  NotSucceedsEqual: "\u2AB0\u0338",
  NotSucceedsSlantEqual: "\u22E1",
  NotSucceedsTilde: "\u227F\u0338",
  NotSuperset: "\u2283\u20D2",
  NotSupersetEqual: "\u2289",
  NotTilde: "\u2241",
  NotTildeEqual: "\u2244",
  NotTildeFullEqual: "\u2247",
  NotTildeTilde: "\u2249",
  NotVerticalBar: "\u2224",
  Nscr: "\u{1D4A9}",
  Ntilde: "\xD1",
  Nu: "\u039D",
  OElig: "\u0152",
  Oacute: "\xD3",
  Ocirc: "\xD4",
  Ocy: "\u041E",
  Odblac: "\u0150",
  Ofr: "\u{1D512}",
  Ograve: "\xD2",
  Omacr: "\u014C",
  Omega: "\u03A9",
  Omicron: "\u039F",
  Oopf: "\u{1D546}",
  OpenCurlyDoubleQuote: "\u201C",
  OpenCurlyQuote: "\u2018",
  Or: "\u2A54",
  Oscr: "\u{1D4AA}",
  Oslash: "\xD8",
  Otilde: "\xD5",
  Otimes: "\u2A37",
  Ouml: "\xD6",
  OverBar: "\u203E",
  OverBrace: "\u23DE",
  OverBracket: "\u23B4",
  OverParenthesis: "\u23DC",
  PartialD: "\u2202",
  Pcy: "\u041F",
  Pfr: "\u{1D513}",
  Phi: "\u03A6",
  Pi: "\u03A0",
  PlusMinus: "\xB1",
  Poincareplane: "\u210C",
  Popf: "\u2119",
  Pr: "\u2ABB",
  Precedes: "\u227A",
  PrecedesEqual: "\u2AAF",
  PrecedesSlantEqual: "\u227C",
  PrecedesTilde: "\u227E",
  Prime: "\u2033",
  Product: "\u220F",
  Proportion: "\u2237",
  Proportional: "\u221D",
  Pscr: "\u{1D4AB}",
  Psi: "\u03A8",
  QUOT: '"',
  Qfr: "\u{1D514}",
  Qopf: "\u211A",
  Qscr: "\u{1D4AC}",
  RBarr: "\u2910",
  REG: "\xAE",
  Racute: "\u0154",
  Rang: "\u27EB",
  Rarr: "\u21A0",
  Rarrtl: "\u2916",
  Rcaron: "\u0158",
  Rcedil: "\u0156",
  Rcy: "\u0420",
  Re: "\u211C",
  ReverseElement: "\u220B",
  ReverseEquilibrium: "\u21CB",
  ReverseUpEquilibrium: "\u296F",
  Rfr: "\u211C",
  Rho: "\u03A1",
  RightAngleBracket: "\u27E9",
  RightArrow: "\u2192",
  RightArrowBar: "\u21E5",
  RightArrowLeftArrow: "\u21C4",
  RightCeiling: "\u2309",
  RightDoubleBracket: "\u27E7",
  RightDownTeeVector: "\u295D",
  RightDownVector: "\u21C2",
  RightDownVectorBar: "\u2955",
  RightFloor: "\u230B",
  RightTee: "\u22A2",
  RightTeeArrow: "\u21A6",
  RightTeeVector: "\u295B",
  RightTriangle: "\u22B3",
  RightTriangleBar: "\u29D0",
  RightTriangleEqual: "\u22B5",
  RightUpDownVector: "\u294F",
  RightUpTeeVector: "\u295C",
  RightUpVector: "\u21BE",
  RightUpVectorBar: "\u2954",
  RightVector: "\u21C0",
  RightVectorBar: "\u2953",
  Rightarrow: "\u21D2",
  Ropf: "\u211D",
  RoundImplies: "\u2970",
  Rrightarrow: "\u21DB",
  Rscr: "\u211B",
  Rsh: "\u21B1",
  RuleDelayed: "\u29F4",
  SHCHcy: "\u0429",
  SHcy: "\u0428",
  SOFTcy: "\u042C",
  Sacute: "\u015A",
  Sc: "\u2ABC",
  Scaron: "\u0160",
  Scedil: "\u015E",
  Scirc: "\u015C",
  Scy: "\u0421",
  Sfr: "\u{1D516}",
  ShortDownArrow: "\u2193",
  ShortLeftArrow: "\u2190",
  ShortRightArrow: "\u2192",
  ShortUpArrow: "\u2191",
  Sigma: "\u03A3",
  SmallCircle: "\u2218",
  Sopf: "\u{1D54A}",
  Sqrt: "\u221A",
  Square: "\u25A1",
  SquareIntersection: "\u2293",
  SquareSubset: "\u228F",
  SquareSubsetEqual: "\u2291",
  SquareSuperset: "\u2290",
  SquareSupersetEqual: "\u2292",
  SquareUnion: "\u2294",
  Sscr: "\u{1D4AE}",
  Star: "\u22C6",
  Sub: "\u22D0",
  Subset: "\u22D0",
  SubsetEqual: "\u2286",
  Succeeds: "\u227B",
  SucceedsEqual: "\u2AB0",
  SucceedsSlantEqual: "\u227D",
  SucceedsTilde: "\u227F",
  SuchThat: "\u220B",
  Sum: "\u2211",
  Sup: "\u22D1",
  Superset: "\u2283",
  SupersetEqual: "\u2287",
  Supset: "\u22D1",
  THORN: "\xDE",
  TRADE: "\u2122",
  TSHcy: "\u040B",
  TScy: "\u0426",
  Tab: "	",
  Tau: "\u03A4",
  Tcaron: "\u0164",
  Tcedil: "\u0162",
  Tcy: "\u0422",
  Tfr: "\u{1D517}",
  Therefore: "\u2234",
  Theta: "\u0398",
  ThickSpace: "\u205F\u200A",
  ThinSpace: "\u2009",
  Tilde: "\u223C",
  TildeEqual: "\u2243",
  TildeFullEqual: "\u2245",
  TildeTilde: "\u2248",
  Topf: "\u{1D54B}",
  TripleDot: "\u20DB",
  Tscr: "\u{1D4AF}",
  Tstrok: "\u0166",
  Uacute: "\xDA",
  Uarr: "\u219F",
  Uarrocir: "\u2949",
  Ubrcy: "\u040E",
  Ubreve: "\u016C",
  Ucirc: "\xDB",
  Ucy: "\u0423",
  Udblac: "\u0170",
  Ufr: "\u{1D518}",
  Ugrave: "\xD9",
  Umacr: "\u016A",
  UnderBar: "_",
  UnderBrace: "\u23DF",
  UnderBracket: "\u23B5",
  UnderParenthesis: "\u23DD",
  Union: "\u22C3",
  UnionPlus: "\u228E",
  Uogon: "\u0172",
  Uopf: "\u{1D54C}",
  UpArrow: "\u2191",
  UpArrowBar: "\u2912",
  UpArrowDownArrow: "\u21C5",
  UpDownArrow: "\u2195",
  UpEquilibrium: "\u296E",
  UpTee: "\u22A5",
  UpTeeArrow: "\u21A5",
  Uparrow: "\u21D1",
  Updownarrow: "\u21D5",
  UpperLeftArrow: "\u2196",
  UpperRightArrow: "\u2197",
  Upsi: "\u03D2",
  Upsilon: "\u03A5",
  Uring: "\u016E",
  Uscr: "\u{1D4B0}",
  Utilde: "\u0168",
  Uuml: "\xDC",
  VDash: "\u22AB",
  Vbar: "\u2AEB",
  Vcy: "\u0412",
  Vdash: "\u22A9",
  Vdashl: "\u2AE6",
  Vee: "\u22C1",
  Verbar: "\u2016",
  Vert: "\u2016",
  VerticalBar: "\u2223",
  VerticalLine: "|",
  VerticalSeparator: "\u2758",
  VerticalTilde: "\u2240",
  VeryThinSpace: "\u200A",
  Vfr: "\u{1D519}",
  Vopf: "\u{1D54D}",
  Vscr: "\u{1D4B1}",
  Vvdash: "\u22AA",
  Wcirc: "\u0174",
  Wedge: "\u22C0",
  Wfr: "\u{1D51A}",
  Wopf: "\u{1D54E}",
  Wscr: "\u{1D4B2}",
  Xfr: "\u{1D51B}",
  Xi: "\u039E",
  Xopf: "\u{1D54F}",
  Xscr: "\u{1D4B3}",
  YAcy: "\u042F",
  YIcy: "\u0407",
  YUcy: "\u042E",
  Yacute: "\xDD",
  Ycirc: "\u0176",
  Ycy: "\u042B",
  Yfr: "\u{1D51C}",
  Yopf: "\u{1D550}",
  Yscr: "\u{1D4B4}",
  Yuml: "\u0178",
  ZHcy: "\u0416",
  Zacute: "\u0179",
  Zcaron: "\u017D",
  Zcy: "\u0417",
  Zdot: "\u017B",
  ZeroWidthSpace: "\u200B",
  Zeta: "\u0396",
  Zfr: "\u2128",
  Zopf: "\u2124",
  Zscr: "\u{1D4B5}",
  aacute: "\xE1",
  abreve: "\u0103",
  ac: "\u223E",
  acE: "\u223E\u0333",
  acd: "\u223F",
  acirc: "\xE2",
  acute: "\xB4",
  acy: "\u0430",
  aelig: "\xE6",
  af: "\u2061",
  afr: "\u{1D51E}",
  agrave: "\xE0",
  alefsym: "\u2135",
  aleph: "\u2135",
  alpha: "\u03B1",
  amacr: "\u0101",
  amalg: "\u2A3F",
  amp: "&",
  and: "\u2227",
  andand: "\u2A55",
  andd: "\u2A5C",
  andslope: "\u2A58",
  andv: "\u2A5A",
  ang: "\u2220",
  ange: "\u29A4",
  angle: "\u2220",
  angmsd: "\u2221",
  angmsdaa: "\u29A8",
  angmsdab: "\u29A9",
  angmsdac: "\u29AA",
  angmsdad: "\u29AB",
  angmsdae: "\u29AC",
  angmsdaf: "\u29AD",
  angmsdag: "\u29AE",
  angmsdah: "\u29AF",
  angrt: "\u221F",
  angrtvb: "\u22BE",
  angrtvbd: "\u299D",
  angsph: "\u2222",
  angst: "\xC5",
  angzarr: "\u237C",
  aogon: "\u0105",
  aopf: "\u{1D552}",
  ap: "\u2248",
  apE: "\u2A70",
  apacir: "\u2A6F",
  ape: "\u224A",
  apid: "\u224B",
  apos: "'",
  approx: "\u2248",
  approxeq: "\u224A",
  aring: "\xE5",
  ascr: "\u{1D4B6}",
  ast: "*",
  asymp: "\u2248",
  asympeq: "\u224D",
  atilde: "\xE3",
  auml: "\xE4",
  awconint: "\u2233",
  awint: "\u2A11",
  bNot: "\u2AED",
  backcong: "\u224C",
  backepsilon: "\u03F6",
  backprime: "\u2035",
  backsim: "\u223D",
  backsimeq: "\u22CD",
  barvee: "\u22BD",
  barwed: "\u2305",
  barwedge: "\u2305",
  bbrk: "\u23B5",
  bbrktbrk: "\u23B6",
  bcong: "\u224C",
  bcy: "\u0431",
  bdquo: "\u201E",
  becaus: "\u2235",
  because: "\u2235",
  bemptyv: "\u29B0",
  bepsi: "\u03F6",
  bernou: "\u212C",
  beta: "\u03B2",
  beth: "\u2136",
  between: "\u226C",
  bfr: "\u{1D51F}",
  bigcap: "\u22C2",
  bigcirc: "\u25EF",
  bigcup: "\u22C3",
  bigodot: "\u2A00",
  bigoplus: "\u2A01",
  bigotimes: "\u2A02",
  bigsqcup: "\u2A06",
  bigstar: "\u2605",
  bigtriangledown: "\u25BD",
  bigtriangleup: "\u25B3",
  biguplus: "\u2A04",
  bigvee: "\u22C1",
  bigwedge: "\u22C0",
  bkarow: "\u290D",
  blacklozenge: "\u29EB",
  blacksquare: "\u25AA",
  blacktriangle: "\u25B4",
  blacktriangledown: "\u25BE",
  blacktriangleleft: "\u25C2",
  blacktriangleright: "\u25B8",
  blank: "\u2423",
  blk12: "\u2592",
  blk14: "\u2591",
  blk34: "\u2593",
  block: "\u2588",
  bne: "=\u20E5",
  bnequiv: "\u2261\u20E5",
  bnot: "\u2310",
  bopf: "\u{1D553}",
  bot: "\u22A5",
  bottom: "\u22A5",
  bowtie: "\u22C8",
  boxDL: "\u2557",
  boxDR: "\u2554",
  boxDl: "\u2556",
  boxDr: "\u2553",
  boxH: "\u2550",
  boxHD: "\u2566",
  boxHU: "\u2569",
  boxHd: "\u2564",
  boxHu: "\u2567",
  boxUL: "\u255D",
  boxUR: "\u255A",
  boxUl: "\u255C",
  boxUr: "\u2559",
  boxV: "\u2551",
  boxVH: "\u256C",
  boxVL: "\u2563",
  boxVR: "\u2560",
  boxVh: "\u256B",
  boxVl: "\u2562",
  boxVr: "\u255F",
  boxbox: "\u29C9",
  boxdL: "\u2555",
  boxdR: "\u2552",
  boxdl: "\u2510",
  boxdr: "\u250C",
  boxh: "\u2500",
  boxhD: "\u2565",
  boxhU: "\u2568",
  boxhd: "\u252C",
  boxhu: "\u2534",
  boxminus: "\u229F",
  boxplus: "\u229E",
  boxtimes: "\u22A0",
  boxuL: "\u255B",
  boxuR: "\u2558",
  boxul: "\u2518",
  boxur: "\u2514",
  boxv: "\u2502",
  boxvH: "\u256A",
  boxvL: "\u2561",
  boxvR: "\u255E",
  boxvh: "\u253C",
  boxvl: "\u2524",
  boxvr: "\u251C",
  bprime: "\u2035",
  breve: "\u02D8",
  brvbar: "\xA6",
  bscr: "\u{1D4B7}",
  bsemi: "\u204F",
  bsim: "\u223D",
  bsime: "\u22CD",
  bsol: "\\",
  bsolb: "\u29C5",
  bsolhsub: "\u27C8",
  bull: "\u2022",
  bullet: "\u2022",
  bump: "\u224E",
  bumpE: "\u2AAE",
  bumpe: "\u224F",
  bumpeq: "\u224F",
  cacute: "\u0107",
  cap: "\u2229",
  capand: "\u2A44",
  capbrcup: "\u2A49",
  capcap: "\u2A4B",
  capcup: "\u2A47",
  capdot: "\u2A40",
  caps: "\u2229\uFE00",
  caret: "\u2041",
  caron: "\u02C7",
  ccaps: "\u2A4D",
  ccaron: "\u010D",
  ccedil: "\xE7",
  ccirc: "\u0109",
  ccups: "\u2A4C",
  ccupssm: "\u2A50",
  cdot: "\u010B",
  cedil: "\xB8",
  cemptyv: "\u29B2",
  cent: "\xA2",
  centerdot: "\xB7",
  cfr: "\u{1D520}",
  chcy: "\u0447",
  check: "\u2713",
  checkmark: "\u2713",
  chi: "\u03C7",
  cir: "\u25CB",
  cirE: "\u29C3",
  circ: "\u02C6",
  circeq: "\u2257",
  circlearrowleft: "\u21BA",
  circlearrowright: "\u21BB",
  circledR: "\xAE",
  circledS: "\u24C8",
  circledast: "\u229B",
  circledcirc: "\u229A",
  circleddash: "\u229D",
  cire: "\u2257",
  cirfnint: "\u2A10",
  cirmid: "\u2AEF",
  cirscir: "\u29C2",
  clubs: "\u2663",
  clubsuit: "\u2663",
  colon: ":",
  colone: "\u2254",
  coloneq: "\u2254",
  comma: ",",
  commat: "@",
  comp: "\u2201",
  compfn: "\u2218",
  complement: "\u2201",
  complexes: "\u2102",
  cong: "\u2245",
  congdot: "\u2A6D",
  conint: "\u222E",
  copf: "\u{1D554}",
  coprod: "\u2210",
  copy: "\xA9",
  copysr: "\u2117",
  crarr: "\u21B5",
  cross: "\u2717",
  cscr: "\u{1D4B8}",
  csub: "\u2ACF",
  csube: "\u2AD1",
  csup: "\u2AD0",
  csupe: "\u2AD2",
  ctdot: "\u22EF",
  cudarrl: "\u2938",
  cudarrr: "\u2935",
  cuepr: "\u22DE",
  cuesc: "\u22DF",
  cularr: "\u21B6",
  cularrp: "\u293D",
  cup: "\u222A",
  cupbrcap: "\u2A48",
  cupcap: "\u2A46",
  cupcup: "\u2A4A",
  cupdot: "\u228D",
  cupor: "\u2A45",
  cups: "\u222A\uFE00",
  curarr: "\u21B7",
  curarrm: "\u293C",
  curlyeqprec: "\u22DE",
  curlyeqsucc: "\u22DF",
  curlyvee: "\u22CE",
  curlywedge: "\u22CF",
  curren: "\xA4",
  curvearrowleft: "\u21B6",
  curvearrowright: "\u21B7",
  cuvee: "\u22CE",
  cuwed: "\u22CF",
  cwconint: "\u2232",
  cwint: "\u2231",
  cylcty: "\u232D",
  dArr: "\u21D3",
  dHar: "\u2965",
  dagger: "\u2020",
  daleth: "\u2138",
  darr: "\u2193",
  dash: "\u2010",
  dashv: "\u22A3",
  dbkarow: "\u290F",
  dblac: "\u02DD",
  dcaron: "\u010F",
  dcy: "\u0434",
  dd: "\u2146",
  ddagger: "\u2021",
  ddarr: "\u21CA",
  ddotseq: "\u2A77",
  deg: "\xB0",
  delta: "\u03B4",
  demptyv: "\u29B1",
  dfisht: "\u297F",
  dfr: "\u{1D521}",
  dharl: "\u21C3",
  dharr: "\u21C2",
  diam: "\u22C4",
  diamond: "\u22C4",
  diamondsuit: "\u2666",
  diams: "\u2666",
  die: "\xA8",
  digamma: "\u03DD",
  disin: "\u22F2",
  div: "\xF7",
  divide: "\xF7",
  divideontimes: "\u22C7",
  divonx: "\u22C7",
  djcy: "\u0452",
  dlcorn: "\u231E",
  dlcrop: "\u230D",
  dollar: "$",
  dopf: "\u{1D555}",
  dot: "\u02D9",
  doteq: "\u2250",
  doteqdot: "\u2251",
  dotminus: "\u2238",
  dotplus: "\u2214",
  dotsquare: "\u22A1",
  doublebarwedge: "\u2306",
  downarrow: "\u2193",
  downdownarrows: "\u21CA",
  downharpoonleft: "\u21C3",
  downharpoonright: "\u21C2",
  drbkarow: "\u2910",
  drcorn: "\u231F",
  drcrop: "\u230C",
  dscr: "\u{1D4B9}",
  dscy: "\u0455",
  dsol: "\u29F6",
  dstrok: "\u0111",
  dtdot: "\u22F1",
  dtri: "\u25BF",
  dtrif: "\u25BE",
  duarr: "\u21F5",
  duhar: "\u296F",
  dwangle: "\u29A6",
  dzcy: "\u045F",
  dzigrarr: "\u27FF",
  eDDot: "\u2A77",
  eDot: "\u2251",
  eacute: "\xE9",
  easter: "\u2A6E",
  ecaron: "\u011B",
  ecir: "\u2256",
  ecirc: "\xEA",
  ecolon: "\u2255",
  ecy: "\u044D",
  edot: "\u0117",
  ee: "\u2147",
  efDot: "\u2252",
  efr: "\u{1D522}",
  eg: "\u2A9A",
  egrave: "\xE8",
  egs: "\u2A96",
  egsdot: "\u2A98",
  el: "\u2A99",
  elinters: "\u23E7",
  ell: "\u2113",
  els: "\u2A95",
  elsdot: "\u2A97",
  emacr: "\u0113",
  empty: "\u2205",
  emptyset: "\u2205",
  emptyv: "\u2205",
  emsp13: "\u2004",
  emsp14: "\u2005",
  emsp: "\u2003",
  eng: "\u014B",
  ensp: "\u2002",
  eogon: "\u0119",
  eopf: "\u{1D556}",
  epar: "\u22D5",
  eparsl: "\u29E3",
  eplus: "\u2A71",
  epsi: "\u03B5",
  epsilon: "\u03B5",
  epsiv: "\u03F5",
  eqcirc: "\u2256",
  eqcolon: "\u2255",
  eqsim: "\u2242",
  eqslantgtr: "\u2A96",
  eqslantless: "\u2A95",
  equals: "=",
  equest: "\u225F",
  equiv: "\u2261",
  equivDD: "\u2A78",
  eqvparsl: "\u29E5",
  erDot: "\u2253",
  erarr: "\u2971",
  escr: "\u212F",
  esdot: "\u2250",
  esim: "\u2242",
  eta: "\u03B7",
  eth: "\xF0",
  euml: "\xEB",
  euro: "\u20AC",
  excl: "!",
  exist: "\u2203",
  expectation: "\u2130",
  exponentiale: "\u2147",
  fallingdotseq: "\u2252",
  fcy: "\u0444",
  female: "\u2640",
  ffilig: "\uFB03",
  fflig: "\uFB00",
  ffllig: "\uFB04",
  ffr: "\u{1D523}",
  filig: "\uFB01",
  fjlig: "fj",
  flat: "\u266D",
  fllig: "\uFB02",
  fltns: "\u25B1",
  fnof: "\u0192",
  fopf: "\u{1D557}",
  forall: "\u2200",
  fork: "\u22D4",
  forkv: "\u2AD9",
  fpartint: "\u2A0D",
  frac12: "\xBD",
  frac13: "\u2153",
  frac14: "\xBC",
  frac15: "\u2155",
  frac16: "\u2159",
  frac18: "\u215B",
  frac23: "\u2154",
  frac25: "\u2156",
  frac34: "\xBE",
  frac35: "\u2157",
  frac38: "\u215C",
  frac45: "\u2158",
  frac56: "\u215A",
  frac58: "\u215D",
  frac78: "\u215E",
  frasl: "\u2044",
  frown: "\u2322",
  fscr: "\u{1D4BB}",
  gE: "\u2267",
  gEl: "\u2A8C",
  gacute: "\u01F5",
  gamma: "\u03B3",
  gammad: "\u03DD",
  gap: "\u2A86",
  gbreve: "\u011F",
  gcirc: "\u011D",
  gcy: "\u0433",
  gdot: "\u0121",
  ge: "\u2265",
  gel: "\u22DB",
  geq: "\u2265",
  geqq: "\u2267",
  geqslant: "\u2A7E",
  ges: "\u2A7E",
  gescc: "\u2AA9",
  gesdot: "\u2A80",
  gesdoto: "\u2A82",
  gesdotol: "\u2A84",
  gesl: "\u22DB\uFE00",
  gesles: "\u2A94",
  gfr: "\u{1D524}",
  gg: "\u226B",
  ggg: "\u22D9",
  gimel: "\u2137",
  gjcy: "\u0453",
  gl: "\u2277",
  glE: "\u2A92",
  gla: "\u2AA5",
  glj: "\u2AA4",
  gnE: "\u2269",
  gnap: "\u2A8A",
  gnapprox: "\u2A8A",
  gne: "\u2A88",
  gneq: "\u2A88",
  gneqq: "\u2269",
  gnsim: "\u22E7",
  gopf: "\u{1D558}",
  grave: "`",
  gscr: "\u210A",
  gsim: "\u2273",
  gsime: "\u2A8E",
  gsiml: "\u2A90",
  gt: ">",
  gtcc: "\u2AA7",
  gtcir: "\u2A7A",
  gtdot: "\u22D7",
  gtlPar: "\u2995",
  gtquest: "\u2A7C",
  gtrapprox: "\u2A86",
  gtrarr: "\u2978",
  gtrdot: "\u22D7",
  gtreqless: "\u22DB",
  gtreqqless: "\u2A8C",
  gtrless: "\u2277",
  gtrsim: "\u2273",
  gvertneqq: "\u2269\uFE00",
  gvnE: "\u2269\uFE00",
  hArr: "\u21D4",
  hairsp: "\u200A",
  half: "\xBD",
  hamilt: "\u210B",
  hardcy: "\u044A",
  harr: "\u2194",
  harrcir: "\u2948",
  harrw: "\u21AD",
  hbar: "\u210F",
  hcirc: "\u0125",
  hearts: "\u2665",
  heartsuit: "\u2665",
  hellip: "\u2026",
  hercon: "\u22B9",
  hfr: "\u{1D525}",
  hksearow: "\u2925",
  hkswarow: "\u2926",
  hoarr: "\u21FF",
  homtht: "\u223B",
  hookleftarrow: "\u21A9",
  hookrightarrow: "\u21AA",
  hopf: "\u{1D559}",
  horbar: "\u2015",
  hscr: "\u{1D4BD}",
  hslash: "\u210F",
  hstrok: "\u0127",
  hybull: "\u2043",
  hyphen: "\u2010",
  iacute: "\xED",
  ic: "\u2063",
  icirc: "\xEE",
  icy: "\u0438",
  iecy: "\u0435",
  iexcl: "\xA1",
  iff: "\u21D4",
  ifr: "\u{1D526}",
  igrave: "\xEC",
  ii: "\u2148",
  iiiint: "\u2A0C",
  iiint: "\u222D",
  iinfin: "\u29DC",
  iiota: "\u2129",
  ijlig: "\u0133",
  imacr: "\u012B",
  image: "\u2111",
  imagline: "\u2110",
  imagpart: "\u2111",
  imath: "\u0131",
  imof: "\u22B7",
  imped: "\u01B5",
  in: "\u2208",
  incare: "\u2105",
  infin: "\u221E",
  infintie: "\u29DD",
  inodot: "\u0131",
  int: "\u222B",
  intcal: "\u22BA",
  integers: "\u2124",
  intercal: "\u22BA",
  intlarhk: "\u2A17",
  intprod: "\u2A3C",
  iocy: "\u0451",
  iogon: "\u012F",
  iopf: "\u{1D55A}",
  iota: "\u03B9",
  iprod: "\u2A3C",
  iquest: "\xBF",
  iscr: "\u{1D4BE}",
  isin: "\u2208",
  isinE: "\u22F9",
  isindot: "\u22F5",
  isins: "\u22F4",
  isinsv: "\u22F3",
  isinv: "\u2208",
  it: "\u2062",
  itilde: "\u0129",
  iukcy: "\u0456",
  iuml: "\xEF",
  jcirc: "\u0135",
  jcy: "\u0439",
  jfr: "\u{1D527}",
  jmath: "\u0237",
  jopf: "\u{1D55B}",
  jscr: "\u{1D4BF}",
  jsercy: "\u0458",
  jukcy: "\u0454",
  kappa: "\u03BA",
  kappav: "\u03F0",
  kcedil: "\u0137",
  kcy: "\u043A",
  kfr: "\u{1D528}",
  kgreen: "\u0138",
  khcy: "\u0445",
  kjcy: "\u045C",
  kopf: "\u{1D55C}",
  kscr: "\u{1D4C0}",
  lAarr: "\u21DA",
  lArr: "\u21D0",
  lAtail: "\u291B",
  lBarr: "\u290E",
  lE: "\u2266",
  lEg: "\u2A8B",
  lHar: "\u2962",
  lacute: "\u013A",
  laemptyv: "\u29B4",
  lagran: "\u2112",
  lambda: "\u03BB",
  lang: "\u27E8",
  langd: "\u2991",
  langle: "\u27E8",
  lap: "\u2A85",
  laquo: "\xAB",
  larr: "\u2190",
  larrb: "\u21E4",
  larrbfs: "\u291F",
  larrfs: "\u291D",
  larrhk: "\u21A9",
  larrlp: "\u21AB",
  larrpl: "\u2939",
  larrsim: "\u2973",
  larrtl: "\u21A2",
  lat: "\u2AAB",
  latail: "\u2919",
  late: "\u2AAD",
  lates: "\u2AAD\uFE00",
  lbarr: "\u290C",
  lbbrk: "\u2772",
  lbrace: "{",
  lbrack: "[",
  lbrke: "\u298B",
  lbrksld: "\u298F",
  lbrkslu: "\u298D",
  lcaron: "\u013E",
  lcedil: "\u013C",
  lceil: "\u2308",
  lcub: "{",
  lcy: "\u043B",
  ldca: "\u2936",
  ldquo: "\u201C",
  ldquor: "\u201E",
  ldrdhar: "\u2967",
  ldrushar: "\u294B",
  ldsh: "\u21B2",
  le: "\u2264",
  leftarrow: "\u2190",
  leftarrowtail: "\u21A2",
  leftharpoondown: "\u21BD",
  leftharpoonup: "\u21BC",
  leftleftarrows: "\u21C7",
  leftrightarrow: "\u2194",
  leftrightarrows: "\u21C6",
  leftrightharpoons: "\u21CB",
  leftrightsquigarrow: "\u21AD",
  leftthreetimes: "\u22CB",
  leg: "\u22DA",
  leq: "\u2264",
  leqq: "\u2266",
  leqslant: "\u2A7D",
  les: "\u2A7D",
  lescc: "\u2AA8",
  lesdot: "\u2A7F",
  lesdoto: "\u2A81",
  lesdotor: "\u2A83",
  lesg: "\u22DA\uFE00",
  lesges: "\u2A93",
  lessapprox: "\u2A85",
  lessdot: "\u22D6",
  lesseqgtr: "\u22DA",
  lesseqqgtr: "\u2A8B",
  lessgtr: "\u2276",
  lesssim: "\u2272",
  lfisht: "\u297C",
  lfloor: "\u230A",
  lfr: "\u{1D529}",
  lg: "\u2276",
  lgE: "\u2A91",
  lhard: "\u21BD",
  lharu: "\u21BC",
  lharul: "\u296A",
  lhblk: "\u2584",
  ljcy: "\u0459",
  ll: "\u226A",
  llarr: "\u21C7",
  llcorner: "\u231E",
  llhard: "\u296B",
  lltri: "\u25FA",
  lmidot: "\u0140",
  lmoust: "\u23B0",
  lmoustache: "\u23B0",
  lnE: "\u2268",
  lnap: "\u2A89",
  lnapprox: "\u2A89",
  lne: "\u2A87",
  lneq: "\u2A87",
  lneqq: "\u2268",
  lnsim: "\u22E6",
  loang: "\u27EC",
  loarr: "\u21FD",
  lobrk: "\u27E6",
  longleftarrow: "\u27F5",
  longleftrightarrow: "\u27F7",
  longmapsto: "\u27FC",
  longrightarrow: "\u27F6",
  looparrowleft: "\u21AB",
  looparrowright: "\u21AC",
  lopar: "\u2985",
  lopf: "\u{1D55D}",
  loplus: "\u2A2D",
  lotimes: "\u2A34",
  lowast: "\u2217",
  lowbar: "_",
  loz: "\u25CA",
  lozenge: "\u25CA",
  lozf: "\u29EB",
  lpar: "(",
  lparlt: "\u2993",
  lrarr: "\u21C6",
  lrcorner: "\u231F",
  lrhar: "\u21CB",
  lrhard: "\u296D",
  lrm: "\u200E",
  lrtri: "\u22BF",
  lsaquo: "\u2039",
  lscr: "\u{1D4C1}",
  lsh: "\u21B0",
  lsim: "\u2272",
  lsime: "\u2A8D",
  lsimg: "\u2A8F",
  lsqb: "[",
  lsquo: "\u2018",
  lsquor: "\u201A",
  lstrok: "\u0142",
  lt: "<",
  ltcc: "\u2AA6",
  ltcir: "\u2A79",
  ltdot: "\u22D6",
  lthree: "\u22CB",
  ltimes: "\u22C9",
  ltlarr: "\u2976",
  ltquest: "\u2A7B",
  ltrPar: "\u2996",
  ltri: "\u25C3",
  ltrie: "\u22B4",
  ltrif: "\u25C2",
  lurdshar: "\u294A",
  luruhar: "\u2966",
  lvertneqq: "\u2268\uFE00",
  lvnE: "\u2268\uFE00",
  mDDot: "\u223A",
  macr: "\xAF",
  male: "\u2642",
  malt: "\u2720",
  maltese: "\u2720",
  map: "\u21A6",
  mapsto: "\u21A6",
  mapstodown: "\u21A7",
  mapstoleft: "\u21A4",
  mapstoup: "\u21A5",
  marker: "\u25AE",
  mcomma: "\u2A29",
  mcy: "\u043C",
  mdash: "\u2014",
  measuredangle: "\u2221",
  mfr: "\u{1D52A}",
  mho: "\u2127",
  micro: "\xB5",
  mid: "\u2223",
  midast: "*",
  midcir: "\u2AF0",
  middot: "\xB7",
  minus: "\u2212",
  minusb: "\u229F",
  minusd: "\u2238",
  minusdu: "\u2A2A",
  mlcp: "\u2ADB",
  mldr: "\u2026",
  mnplus: "\u2213",
  models: "\u22A7",
  mopf: "\u{1D55E}",
  mp: "\u2213",
  mscr: "\u{1D4C2}",
  mstpos: "\u223E",
  mu: "\u03BC",
  multimap: "\u22B8",
  mumap: "\u22B8",
  nGg: "\u22D9\u0338",
  nGt: "\u226B\u20D2",
  nGtv: "\u226B\u0338",
  nLeftarrow: "\u21CD",
  nLeftrightarrow: "\u21CE",
  nLl: "\u22D8\u0338",
  nLt: "\u226A\u20D2",
  nLtv: "\u226A\u0338",
  nRightarrow: "\u21CF",
  nVDash: "\u22AF",
  nVdash: "\u22AE",
  nabla: "\u2207",
  nacute: "\u0144",
  nang: "\u2220\u20D2",
  nap: "\u2249",
  napE: "\u2A70\u0338",
  napid: "\u224B\u0338",
  napos: "\u0149",
  napprox: "\u2249",
  natur: "\u266E",
  natural: "\u266E",
  naturals: "\u2115",
  nbsp: "\xA0",
  nbump: "\u224E\u0338",
  nbumpe: "\u224F\u0338",
  ncap: "\u2A43",
  ncaron: "\u0148",
  ncedil: "\u0146",
  ncong: "\u2247",
  ncongdot: "\u2A6D\u0338",
  ncup: "\u2A42",
  ncy: "\u043D",
  ndash: "\u2013",
  ne: "\u2260",
  neArr: "\u21D7",
  nearhk: "\u2924",
  nearr: "\u2197",
  nearrow: "\u2197",
  nedot: "\u2250\u0338",
  nequiv: "\u2262",
  nesear: "\u2928",
  nesim: "\u2242\u0338",
  nexist: "\u2204",
  nexists: "\u2204",
  nfr: "\u{1D52B}",
  ngE: "\u2267\u0338",
  nge: "\u2271",
  ngeq: "\u2271",
  ngeqq: "\u2267\u0338",
  ngeqslant: "\u2A7E\u0338",
  nges: "\u2A7E\u0338",
  ngsim: "\u2275",
  ngt: "\u226F",
  ngtr: "\u226F",
  nhArr: "\u21CE",
  nharr: "\u21AE",
  nhpar: "\u2AF2",
  ni: "\u220B",
  nis: "\u22FC",
  nisd: "\u22FA",
  niv: "\u220B",
  njcy: "\u045A",
  nlArr: "\u21CD",
  nlE: "\u2266\u0338",
  nlarr: "\u219A",
  nldr: "\u2025",
  nle: "\u2270",
  nleftarrow: "\u219A",
  nleftrightarrow: "\u21AE",
  nleq: "\u2270",
  nleqq: "\u2266\u0338",
  nleqslant: "\u2A7D\u0338",
  nles: "\u2A7D\u0338",
  nless: "\u226E",
  nlsim: "\u2274",
  nlt: "\u226E",
  nltri: "\u22EA",
  nltrie: "\u22EC",
  nmid: "\u2224",
  nopf: "\u{1D55F}",
  not: "\xAC",
  notin: "\u2209",
  notinE: "\u22F9\u0338",
  notindot: "\u22F5\u0338",
  notinva: "\u2209",
  notinvb: "\u22F7",
  notinvc: "\u22F6",
  notni: "\u220C",
  notniva: "\u220C",
  notnivb: "\u22FE",
  notnivc: "\u22FD",
  npar: "\u2226",
  nparallel: "\u2226",
  nparsl: "\u2AFD\u20E5",
  npart: "\u2202\u0338",
  npolint: "\u2A14",
  npr: "\u2280",
  nprcue: "\u22E0",
  npre: "\u2AAF\u0338",
  nprec: "\u2280",
  npreceq: "\u2AAF\u0338",
  nrArr: "\u21CF",
  nrarr: "\u219B",
  nrarrc: "\u2933\u0338",
  nrarrw: "\u219D\u0338",
  nrightarrow: "\u219B",
  nrtri: "\u22EB",
  nrtrie: "\u22ED",
  nsc: "\u2281",
  nsccue: "\u22E1",
  nsce: "\u2AB0\u0338",
  nscr: "\u{1D4C3}",
  nshortmid: "\u2224",
  nshortparallel: "\u2226",
  nsim: "\u2241",
  nsime: "\u2244",
  nsimeq: "\u2244",
  nsmid: "\u2224",
  nspar: "\u2226",
  nsqsube: "\u22E2",
  nsqsupe: "\u22E3",
  nsub: "\u2284",
  nsubE: "\u2AC5\u0338",
  nsube: "\u2288",
  nsubset: "\u2282\u20D2",
  nsubseteq: "\u2288",
  nsubseteqq: "\u2AC5\u0338",
  nsucc: "\u2281",
  nsucceq: "\u2AB0\u0338",
  nsup: "\u2285",
  nsupE: "\u2AC6\u0338",
  nsupe: "\u2289",
  nsupset: "\u2283\u20D2",
  nsupseteq: "\u2289",
  nsupseteqq: "\u2AC6\u0338",
  ntgl: "\u2279",
  ntilde: "\xF1",
  ntlg: "\u2278",
  ntriangleleft: "\u22EA",
  ntrianglelefteq: "\u22EC",
  ntriangleright: "\u22EB",
  ntrianglerighteq: "\u22ED",
  nu: "\u03BD",
  num: "#",
  numero: "\u2116",
  numsp: "\u2007",
  nvDash: "\u22AD",
  nvHarr: "\u2904",
  nvap: "\u224D\u20D2",
  nvdash: "\u22AC",
  nvge: "\u2265\u20D2",
  nvgt: ">\u20D2",
  nvinfin: "\u29DE",
  nvlArr: "\u2902",
  nvle: "\u2264\u20D2",
  nvlt: "<\u20D2",
  nvltrie: "\u22B4\u20D2",
  nvrArr: "\u2903",
  nvrtrie: "\u22B5\u20D2",
  nvsim: "\u223C\u20D2",
  nwArr: "\u21D6",
  nwarhk: "\u2923",
  nwarr: "\u2196",
  nwarrow: "\u2196",
  nwnear: "\u2927",
  oS: "\u24C8",
  oacute: "\xF3",
  oast: "\u229B",
  ocir: "\u229A",
  ocirc: "\xF4",
  ocy: "\u043E",
  odash: "\u229D",
  odblac: "\u0151",
  odiv: "\u2A38",
  odot: "\u2299",
  odsold: "\u29BC",
  oelig: "\u0153",
  ofcir: "\u29BF",
  ofr: "\u{1D52C}",
  ogon: "\u02DB",
  ograve: "\xF2",
  ogt: "\u29C1",
  ohbar: "\u29B5",
  ohm: "\u03A9",
  oint: "\u222E",
  olarr: "\u21BA",
  olcir: "\u29BE",
  olcross: "\u29BB",
  oline: "\u203E",
  olt: "\u29C0",
  omacr: "\u014D",
  omega: "\u03C9",
  omicron: "\u03BF",
  omid: "\u29B6",
  ominus: "\u2296",
  oopf: "\u{1D560}",
  opar: "\u29B7",
  operp: "\u29B9",
  oplus: "\u2295",
  or: "\u2228",
  orarr: "\u21BB",
  ord: "\u2A5D",
  order: "\u2134",
  orderof: "\u2134",
  ordf: "\xAA",
  ordm: "\xBA",
  origof: "\u22B6",
  oror: "\u2A56",
  orslope: "\u2A57",
  orv: "\u2A5B",
  oscr: "\u2134",
  oslash: "\xF8",
  osol: "\u2298",
  otilde: "\xF5",
  otimes: "\u2297",
  otimesas: "\u2A36",
  ouml: "\xF6",
  ovbar: "\u233D",
  par: "\u2225",
  para: "\xB6",
  parallel: "\u2225",
  parsim: "\u2AF3",
  parsl: "\u2AFD",
  part: "\u2202",
  pcy: "\u043F",
  percnt: "%",
  period: ".",
  permil: "\u2030",
  perp: "\u22A5",
  pertenk: "\u2031",
  pfr: "\u{1D52D}",
  phi: "\u03C6",
  phiv: "\u03D5",
  phmmat: "\u2133",
  phone: "\u260E",
  pi: "\u03C0",
  pitchfork: "\u22D4",
  piv: "\u03D6",
  planck: "\u210F",
  planckh: "\u210E",
  plankv: "\u210F",
  plus: "+",
  plusacir: "\u2A23",
  plusb: "\u229E",
  pluscir: "\u2A22",
  plusdo: "\u2214",
  plusdu: "\u2A25",
  pluse: "\u2A72",
  plusmn: "\xB1",
  plussim: "\u2A26",
  plustwo: "\u2A27",
  pm: "\xB1",
  pointint: "\u2A15",
  popf: "\u{1D561}",
  pound: "\xA3",
  pr: "\u227A",
  prE: "\u2AB3",
  prap: "\u2AB7",
  prcue: "\u227C",
  pre: "\u2AAF",
  prec: "\u227A",
  precapprox: "\u2AB7",
  preccurlyeq: "\u227C",
  preceq: "\u2AAF",
  precnapprox: "\u2AB9",
  precneqq: "\u2AB5",
  precnsim: "\u22E8",
  precsim: "\u227E",
  prime: "\u2032",
  primes: "\u2119",
  prnE: "\u2AB5",
  prnap: "\u2AB9",
  prnsim: "\u22E8",
  prod: "\u220F",
  profalar: "\u232E",
  profline: "\u2312",
  profsurf: "\u2313",
  prop: "\u221D",
  propto: "\u221D",
  prsim: "\u227E",
  prurel: "\u22B0",
  pscr: "\u{1D4C5}",
  psi: "\u03C8",
  puncsp: "\u2008",
  qfr: "\u{1D52E}",
  qint: "\u2A0C",
  qopf: "\u{1D562}",
  qprime: "\u2057",
  qscr: "\u{1D4C6}",
  quaternions: "\u210D",
  quatint: "\u2A16",
  quest: "?",
  questeq: "\u225F",
  quot: '"',
  rAarr: "\u21DB",
  rArr: "\u21D2",
  rAtail: "\u291C",
  rBarr: "\u290F",
  rHar: "\u2964",
  race: "\u223D\u0331",
  racute: "\u0155",
  radic: "\u221A",
  raemptyv: "\u29B3",
  rang: "\u27E9",
  rangd: "\u2992",
  range: "\u29A5",
  rangle: "\u27E9",
  raquo: "\xBB",
  rarr: "\u2192",
  rarrap: "\u2975",
  rarrb: "\u21E5",
  rarrbfs: "\u2920",
  rarrc: "\u2933",
  rarrfs: "\u291E",
  rarrhk: "\u21AA",
  rarrlp: "\u21AC",
  rarrpl: "\u2945",
  rarrsim: "\u2974",
  rarrtl: "\u21A3",
  rarrw: "\u219D",
  ratail: "\u291A",
  ratio: "\u2236",
  rationals: "\u211A",
  rbarr: "\u290D",
  rbbrk: "\u2773",
  rbrace: "}",
  rbrack: "]",
  rbrke: "\u298C",
  rbrksld: "\u298E",
  rbrkslu: "\u2990",
  rcaron: "\u0159",
  rcedil: "\u0157",
  rceil: "\u2309",
  rcub: "}",
  rcy: "\u0440",
  rdca: "\u2937",
  rdldhar: "\u2969",
  rdquo: "\u201D",
  rdquor: "\u201D",
  rdsh: "\u21B3",
  real: "\u211C",
  realine: "\u211B",
  realpart: "\u211C",
  reals: "\u211D",
  rect: "\u25AD",
  reg: "\xAE",
  rfisht: "\u297D",
  rfloor: "\u230B",
  rfr: "\u{1D52F}",
  rhard: "\u21C1",
  rharu: "\u21C0",
  rharul: "\u296C",
  rho: "\u03C1",
  rhov: "\u03F1",
  rightarrow: "\u2192",
  rightarrowtail: "\u21A3",
  rightharpoondown: "\u21C1",
  rightharpoonup: "\u21C0",
  rightleftarrows: "\u21C4",
  rightleftharpoons: "\u21CC",
  rightrightarrows: "\u21C9",
  rightsquigarrow: "\u219D",
  rightthreetimes: "\u22CC",
  ring: "\u02DA",
  risingdotseq: "\u2253",
  rlarr: "\u21C4",
  rlhar: "\u21CC",
  rlm: "\u200F",
  rmoust: "\u23B1",
  rmoustache: "\u23B1",
  rnmid: "\u2AEE",
  roang: "\u27ED",
  roarr: "\u21FE",
  robrk: "\u27E7",
  ropar: "\u2986",
  ropf: "\u{1D563}",
  roplus: "\u2A2E",
  rotimes: "\u2A35",
  rpar: ")",
  rpargt: "\u2994",
  rppolint: "\u2A12",
  rrarr: "\u21C9",
  rsaquo: "\u203A",
  rscr: "\u{1D4C7}",
  rsh: "\u21B1",
  rsqb: "]",
  rsquo: "\u2019",
  rsquor: "\u2019",
  rthree: "\u22CC",
  rtimes: "\u22CA",
  rtri: "\u25B9",
  rtrie: "\u22B5",
  rtrif: "\u25B8",
  rtriltri: "\u29CE",
  ruluhar: "\u2968",
  rx: "\u211E",
  sacute: "\u015B",
  sbquo: "\u201A",
  sc: "\u227B",
  scE: "\u2AB4",
  scap: "\u2AB8",
  scaron: "\u0161",
  sccue: "\u227D",
  sce: "\u2AB0",
  scedil: "\u015F",
  scirc: "\u015D",
  scnE: "\u2AB6",
  scnap: "\u2ABA",
  scnsim: "\u22E9",
  scpolint: "\u2A13",
  scsim: "\u227F",
  scy: "\u0441",
  sdot: "\u22C5",
  sdotb: "\u22A1",
  sdote: "\u2A66",
  seArr: "\u21D8",
  searhk: "\u2925",
  searr: "\u2198",
  searrow: "\u2198",
  sect: "\xA7",
  semi: ";",
  seswar: "\u2929",
  setminus: "\u2216",
  setmn: "\u2216",
  sext: "\u2736",
  sfr: "\u{1D530}",
  sfrown: "\u2322",
  sharp: "\u266F",
  shchcy: "\u0449",
  shcy: "\u0448",
  shortmid: "\u2223",
  shortparallel: "\u2225",
  shy: "\xAD",
  sigma: "\u03C3",
  sigmaf: "\u03C2",
  sigmav: "\u03C2",
  sim: "\u223C",
  simdot: "\u2A6A",
  sime: "\u2243",
  simeq: "\u2243",
  simg: "\u2A9E",
  simgE: "\u2AA0",
  siml: "\u2A9D",
  simlE: "\u2A9F",
  simne: "\u2246",
  simplus: "\u2A24",
  simrarr: "\u2972",
  slarr: "\u2190",
  smallsetminus: "\u2216",
  smashp: "\u2A33",
  smeparsl: "\u29E4",
  smid: "\u2223",
  smile: "\u2323",
  smt: "\u2AAA",
  smte: "\u2AAC",
  smtes: "\u2AAC\uFE00",
  softcy: "\u044C",
  sol: "/",
  solb: "\u29C4",
  solbar: "\u233F",
  sopf: "\u{1D564}",
  spades: "\u2660",
  spadesuit: "\u2660",
  spar: "\u2225",
  sqcap: "\u2293",
  sqcaps: "\u2293\uFE00",
  sqcup: "\u2294",
  sqcups: "\u2294\uFE00",
  sqsub: "\u228F",
  sqsube: "\u2291",
  sqsubset: "\u228F",
  sqsubseteq: "\u2291",
  sqsup: "\u2290",
  sqsupe: "\u2292",
  sqsupset: "\u2290",
  sqsupseteq: "\u2292",
  squ: "\u25A1",
  square: "\u25A1",
  squarf: "\u25AA",
  squf: "\u25AA",
  srarr: "\u2192",
  sscr: "\u{1D4C8}",
  ssetmn: "\u2216",
  ssmile: "\u2323",
  sstarf: "\u22C6",
  star: "\u2606",
  starf: "\u2605",
  straightepsilon: "\u03F5",
  straightphi: "\u03D5",
  strns: "\xAF",
  sub: "\u2282",
  subE: "\u2AC5",
  subdot: "\u2ABD",
  sube: "\u2286",
  subedot: "\u2AC3",
  submult: "\u2AC1",
  subnE: "\u2ACB",
  subne: "\u228A",
  subplus: "\u2ABF",
  subrarr: "\u2979",
  subset: "\u2282",
  subseteq: "\u2286",
  subseteqq: "\u2AC5",
  subsetneq: "\u228A",
  subsetneqq: "\u2ACB",
  subsim: "\u2AC7",
  subsub: "\u2AD5",
  subsup: "\u2AD3",
  succ: "\u227B",
  succapprox: "\u2AB8",
  succcurlyeq: "\u227D",
  succeq: "\u2AB0",
  succnapprox: "\u2ABA",
  succneqq: "\u2AB6",
  succnsim: "\u22E9",
  succsim: "\u227F",
  sum: "\u2211",
  sung: "\u266A",
  sup1: "\xB9",
  sup2: "\xB2",
  sup3: "\xB3",
  sup: "\u2283",
  supE: "\u2AC6",
  supdot: "\u2ABE",
  supdsub: "\u2AD8",
  supe: "\u2287",
  supedot: "\u2AC4",
  suphsol: "\u27C9",
  suphsub: "\u2AD7",
  suplarr: "\u297B",
  supmult: "\u2AC2",
  supnE: "\u2ACC",
  supne: "\u228B",
  supplus: "\u2AC0",
  supset: "\u2283",
  supseteq: "\u2287",
  supseteqq: "\u2AC6",
  supsetneq: "\u228B",
  supsetneqq: "\u2ACC",
  supsim: "\u2AC8",
  supsub: "\u2AD4",
  supsup: "\u2AD6",
  swArr: "\u21D9",
  swarhk: "\u2926",
  swarr: "\u2199",
  swarrow: "\u2199",
  swnwar: "\u292A",
  szlig: "\xDF",
  target: "\u2316",
  tau: "\u03C4",
  tbrk: "\u23B4",
  tcaron: "\u0165",
  tcedil: "\u0163",
  tcy: "\u0442",
  tdot: "\u20DB",
  telrec: "\u2315",
  tfr: "\u{1D531}",
  there4: "\u2234",
  therefore: "\u2234",
  theta: "\u03B8",
  thetasym: "\u03D1",
  thetav: "\u03D1",
  thickapprox: "\u2248",
  thicksim: "\u223C",
  thinsp: "\u2009",
  thkap: "\u2248",
  thksim: "\u223C",
  thorn: "\xFE",
  tilde: "\u02DC",
  times: "\xD7",
  timesb: "\u22A0",
  timesbar: "\u2A31",
  timesd: "\u2A30",
  tint: "\u222D",
  toea: "\u2928",
  top: "\u22A4",
  topbot: "\u2336",
  topcir: "\u2AF1",
  topf: "\u{1D565}",
  topfork: "\u2ADA",
  tosa: "\u2929",
  tprime: "\u2034",
  trade: "\u2122",
  triangle: "\u25B5",
  triangledown: "\u25BF",
  triangleleft: "\u25C3",
  trianglelefteq: "\u22B4",
  triangleq: "\u225C",
  triangleright: "\u25B9",
  trianglerighteq: "\u22B5",
  tridot: "\u25EC",
  trie: "\u225C",
  triminus: "\u2A3A",
  triplus: "\u2A39",
  trisb: "\u29CD",
  tritime: "\u2A3B",
  trpezium: "\u23E2",
  tscr: "\u{1D4C9}",
  tscy: "\u0446",
  tshcy: "\u045B",
  tstrok: "\u0167",
  twixt: "\u226C",
  twoheadleftarrow: "\u219E",
  twoheadrightarrow: "\u21A0",
  uArr: "\u21D1",
  uHar: "\u2963",
  uacute: "\xFA",
  uarr: "\u2191",
  ubrcy: "\u045E",
  ubreve: "\u016D",
  ucirc: "\xFB",
  ucy: "\u0443",
  udarr: "\u21C5",
  udblac: "\u0171",
  udhar: "\u296E",
  ufisht: "\u297E",
  ufr: "\u{1D532}",
  ugrave: "\xF9",
  uharl: "\u21BF",
  uharr: "\u21BE",
  uhblk: "\u2580",
  ulcorn: "\u231C",
  ulcorner: "\u231C",
  ulcrop: "\u230F",
  ultri: "\u25F8",
  umacr: "\u016B",
  uml: "\xA8",
  uogon: "\u0173",
  uopf: "\u{1D566}",
  uparrow: "\u2191",
  updownarrow: "\u2195",
  upharpoonleft: "\u21BF",
  upharpoonright: "\u21BE",
  uplus: "\u228E",
  upsi: "\u03C5",
  upsih: "\u03D2",
  upsilon: "\u03C5",
  upuparrows: "\u21C8",
  urcorn: "\u231D",
  urcorner: "\u231D",
  urcrop: "\u230E",
  uring: "\u016F",
  urtri: "\u25F9",
  uscr: "\u{1D4CA}",
  utdot: "\u22F0",
  utilde: "\u0169",
  utri: "\u25B5",
  utrif: "\u25B4",
  uuarr: "\u21C8",
  uuml: "\xFC",
  uwangle: "\u29A7",
  vArr: "\u21D5",
  vBar: "\u2AE8",
  vBarv: "\u2AE9",
  vDash: "\u22A8",
  vangrt: "\u299C",
  varepsilon: "\u03F5",
  varkappa: "\u03F0",
  varnothing: "\u2205",
  varphi: "\u03D5",
  varpi: "\u03D6",
  varpropto: "\u221D",
  varr: "\u2195",
  varrho: "\u03F1",
  varsigma: "\u03C2",
  varsubsetneq: "\u228A\uFE00",
  varsubsetneqq: "\u2ACB\uFE00",
  varsupsetneq: "\u228B\uFE00",
  varsupsetneqq: "\u2ACC\uFE00",
  vartheta: "\u03D1",
  vartriangleleft: "\u22B2",
  vartriangleright: "\u22B3",
  vcy: "\u0432",
  vdash: "\u22A2",
  vee: "\u2228",
  veebar: "\u22BB",
  veeeq: "\u225A",
  vellip: "\u22EE",
  verbar: "|",
  vert: "|",
  vfr: "\u{1D533}",
  vltri: "\u22B2",
  vnsub: "\u2282\u20D2",
  vnsup: "\u2283\u20D2",
  vopf: "\u{1D567}",
  vprop: "\u221D",
  vrtri: "\u22B3",
  vscr: "\u{1D4CB}",
  vsubnE: "\u2ACB\uFE00",
  vsubne: "\u228A\uFE00",
  vsupnE: "\u2ACC\uFE00",
  vsupne: "\u228B\uFE00",
  vzigzag: "\u299A",
  wcirc: "\u0175",
  wedbar: "\u2A5F",
  wedge: "\u2227",
  wedgeq: "\u2259",
  weierp: "\u2118",
  wfr: "\u{1D534}",
  wopf: "\u{1D568}",
  wp: "\u2118",
  wr: "\u2240",
  wreath: "\u2240",
  wscr: "\u{1D4CC}",
  xcap: "\u22C2",
  xcirc: "\u25EF",
  xcup: "\u22C3",
  xdtri: "\u25BD",
  xfr: "\u{1D535}",
  xhArr: "\u27FA",
  xharr: "\u27F7",
  xi: "\u03BE",
  xlArr: "\u27F8",
  xlarr: "\u27F5",
  xmap: "\u27FC",
  xnis: "\u22FB",
  xodot: "\u2A00",
  xopf: "\u{1D569}",
  xoplus: "\u2A01",
  xotime: "\u2A02",
  xrArr: "\u27F9",
  xrarr: "\u27F6",
  xscr: "\u{1D4CD}",
  xsqcup: "\u2A06",
  xuplus: "\u2A04",
  xutri: "\u25B3",
  xvee: "\u22C1",
  xwedge: "\u22C0",
  yacute: "\xFD",
  yacy: "\u044F",
  ycirc: "\u0177",
  ycy: "\u044B",
  yen: "\xA5",
  yfr: "\u{1D536}",
  yicy: "\u0457",
  yopf: "\u{1D56A}",
  yscr: "\u{1D4CE}",
  yucy: "\u044E",
  yuml: "\xFF",
  zacute: "\u017A",
  zcaron: "\u017E",
  zcy: "\u0437",
  zdot: "\u017C",
  zeetrf: "\u2128",
  zeta: "\u03B6",
  zfr: "\u{1D537}",
  zhcy: "\u0436",
  zigrarr: "\u21DD",
  zopf: "\u{1D56B}",
  zscr: "\u{1D4CF}",
  zwj: "\u200D",
  zwnj: "\u200C"
};

// node_modules/decode-named-character-reference/index.js
var own3 = {}.hasOwnProperty;
function decodeNamedCharacterReference(value2) {
  return own3.call(characterEntities, value2) ? characterEntities[value2] : false;
}

// node_modules/micromark-core-commonmark/lib/character-reference.js
var characterReference = {
  name: "characterReference",
  tokenize: tokenizeCharacterReference
};
function tokenizeCharacterReference(effects, ok2, nok) {
  const self2 = this;
  let size = 0;
  let max;
  let test;
  return start3;
  function start3(code2) {
    effects.enter("characterReference");
    effects.enter("characterReferenceMarker");
    effects.consume(code2);
    effects.exit("characterReferenceMarker");
    return open;
  }
  function open(code2) {
    if (code2 === 35) {
      effects.enter("characterReferenceMarkerNumeric");
      effects.consume(code2);
      effects.exit("characterReferenceMarkerNumeric");
      return numeric;
    }
    effects.enter("characterReferenceValue");
    max = 31;
    test = asciiAlphanumeric;
    return value2(code2);
  }
  function numeric(code2) {
    if (code2 === 88 || code2 === 120) {
      effects.enter("characterReferenceMarkerHexadecimal");
      effects.consume(code2);
      effects.exit("characterReferenceMarkerHexadecimal");
      effects.enter("characterReferenceValue");
      max = 6;
      test = asciiHexDigit;
      return value2;
    }
    effects.enter("characterReferenceValue");
    max = 7;
    test = asciiDigit;
    return value2(code2);
  }
  function value2(code2) {
    let token2;
    if (code2 === 59 && size) {
      token2 = effects.exit("characterReferenceValue");
      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self2.sliceSerialize(token2))) {
        return nok(code2);
      }
      effects.enter("characterReferenceMarker");
      effects.consume(code2);
      effects.exit("characterReferenceMarker");
      effects.exit("characterReference");
      return ok2;
    }
    if (test(code2) && size++ < max) {
      effects.consume(code2);
      return value2;
    }
    return nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/code-fenced.js
var codeFenced = {
  name: "codeFenced",
  tokenize: tokenizeCodeFenced,
  concrete: true
};
function tokenizeCodeFenced(effects, ok2, nok) {
  const self2 = this;
  const closingFenceConstruct = {
    tokenize: tokenizeClosingFence,
    partial: true
  };
  const nonLazyLine = {
    tokenize: tokenizeNonLazyLine,
    partial: true
  };
  const tail = this.events[this.events.length - 1];
  const initialPrefix = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
  let sizeOpen = 0;
  let marker;
  return start3;
  function start3(code2) {
    effects.enter("codeFenced");
    effects.enter("codeFencedFence");
    effects.enter("codeFencedFenceSequence");
    marker = code2;
    return sequenceOpen(code2);
  }
  function sequenceOpen(code2) {
    if (code2 === marker) {
      effects.consume(code2);
      sizeOpen++;
      return sequenceOpen;
    }
    effects.exit("codeFencedFenceSequence");
    return sizeOpen < 3 ? nok(code2) : factorySpace(effects, infoOpen, "whitespace")(code2);
  }
  function infoOpen(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      return openAfter(code2);
    }
    effects.enter("codeFencedFenceInfo");
    effects.enter("chunkString", {
      contentType: "string"
    });
    return info(code2);
  }
  function info(code2) {
    if (code2 === null || markdownLineEndingOrSpace(code2)) {
      effects.exit("chunkString");
      effects.exit("codeFencedFenceInfo");
      return factorySpace(effects, infoAfter, "whitespace")(code2);
    }
    if (code2 === 96 && code2 === marker)
      return nok(code2);
    effects.consume(code2);
    return info;
  }
  function infoAfter(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      return openAfter(code2);
    }
    effects.enter("codeFencedFenceMeta");
    effects.enter("chunkString", {
      contentType: "string"
    });
    return meta(code2);
  }
  function meta(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("chunkString");
      effects.exit("codeFencedFenceMeta");
      return openAfter(code2);
    }
    if (code2 === 96 && code2 === marker)
      return nok(code2);
    effects.consume(code2);
    return meta;
  }
  function openAfter(code2) {
    effects.exit("codeFencedFence");
    return self2.interrupt ? ok2(code2) : contentStart(code2);
  }
  function contentStart(code2) {
    if (code2 === null) {
      return after(code2);
    }
    if (markdownLineEnding(code2)) {
      return effects.attempt(
        nonLazyLine,
        effects.attempt(
          closingFenceConstruct,
          after,
          initialPrefix ? factorySpace(
            effects,
            contentStart,
            "linePrefix",
            initialPrefix + 1
          ) : contentStart
        ),
        after
      )(code2);
    }
    effects.enter("codeFlowValue");
    return contentContinue(code2);
  }
  function contentContinue(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("codeFlowValue");
      return contentStart(code2);
    }
    effects.consume(code2);
    return contentContinue;
  }
  function after(code2) {
    effects.exit("codeFenced");
    return ok2(code2);
  }
  function tokenizeNonLazyLine(effects2, ok3, nok2) {
    const self3 = this;
    return start4;
    function start4(code2) {
      effects2.enter("lineEnding");
      effects2.consume(code2);
      effects2.exit("lineEnding");
      return lineStart;
    }
    function lineStart(code2) {
      return self3.parser.lazy[self3.now().line] ? nok2(code2) : ok3(code2);
    }
  }
  function tokenizeClosingFence(effects2, ok3, nok2) {
    let size = 0;
    return factorySpace(
      effects2,
      closingSequenceStart,
      "linePrefix",
      this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4
    );
    function closingSequenceStart(code2) {
      effects2.enter("codeFencedFence");
      effects2.enter("codeFencedFenceSequence");
      return closingSequence(code2);
    }
    function closingSequence(code2) {
      if (code2 === marker) {
        effects2.consume(code2);
        size++;
        return closingSequence;
      }
      if (size < sizeOpen)
        return nok2(code2);
      effects2.exit("codeFencedFenceSequence");
      return factorySpace(effects2, closingSequenceEnd, "whitespace")(code2);
    }
    function closingSequenceEnd(code2) {
      if (code2 === null || markdownLineEnding(code2)) {
        effects2.exit("codeFencedFence");
        return ok3(code2);
      }
      return nok2(code2);
    }
  }
}

// node_modules/micromark-core-commonmark/lib/code-indented.js
var codeIndented = {
  name: "codeIndented",
  tokenize: tokenizeCodeIndented
};
var indentedContent = {
  tokenize: tokenizeIndentedContent,
  partial: true
};
function tokenizeCodeIndented(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    effects.enter("codeIndented");
    return factorySpace(effects, afterStartPrefix, "linePrefix", 4 + 1)(code2);
  }
  function afterStartPrefix(code2) {
    const tail = self2.events[self2.events.length - 1];
    return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? afterPrefix(code2) : nok(code2);
  }
  function afterPrefix(code2) {
    if (code2 === null) {
      return after(code2);
    }
    if (markdownLineEnding(code2)) {
      return effects.attempt(indentedContent, afterPrefix, after)(code2);
    }
    effects.enter("codeFlowValue");
    return content3(code2);
  }
  function content3(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("codeFlowValue");
      return afterPrefix(code2);
    }
    effects.consume(code2);
    return content3;
  }
  function after(code2) {
    effects.exit("codeIndented");
    return ok2(code2);
  }
}
function tokenizeIndentedContent(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    if (self2.parser.lazy[self2.now().line]) {
      return nok(code2);
    }
    if (markdownLineEnding(code2)) {
      effects.enter("lineEnding");
      effects.consume(code2);
      effects.exit("lineEnding");
      return start3;
    }
    return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code2);
  }
  function afterPrefix(code2) {
    const tail = self2.events[self2.events.length - 1];
    return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok2(code2) : markdownLineEnding(code2) ? start3(code2) : nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/code-text.js
var codeText = {
  name: "codeText",
  tokenize: tokenizeCodeText,
  resolve: resolveCodeText,
  previous
};
function resolveCodeText(events) {
  let tailExitIndex = events.length - 4;
  let headEnterIndex = 3;
  let index2;
  let enter;
  if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
    index2 = headEnterIndex;
    while (++index2 < tailExitIndex) {
      if (events[index2][1].type === "codeTextData") {
        events[headEnterIndex][1].type = "codeTextPadding";
        events[tailExitIndex][1].type = "codeTextPadding";
        headEnterIndex += 2;
        tailExitIndex -= 2;
        break;
      }
    }
  }
  index2 = headEnterIndex - 1;
  tailExitIndex++;
  while (++index2 <= tailExitIndex) {
    if (enter === void 0) {
      if (index2 !== tailExitIndex && events[index2][1].type !== "lineEnding") {
        enter = index2;
      }
    } else if (index2 === tailExitIndex || events[index2][1].type === "lineEnding") {
      events[enter][1].type = "codeTextData";
      if (index2 !== enter + 2) {
        events[enter][1].end = events[index2 - 1][1].end;
        events.splice(enter + 2, index2 - enter - 2);
        tailExitIndex -= index2 - enter - 2;
        index2 = enter + 2;
      }
      enter = void 0;
    }
  }
  return events;
}
function previous(code2) {
  return code2 !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
}
function tokenizeCodeText(effects, ok2, nok) {
  const self2 = this;
  let sizeOpen = 0;
  let size;
  let token2;
  return start3;
  function start3(code2) {
    effects.enter("codeText");
    effects.enter("codeTextSequence");
    return openingSequence(code2);
  }
  function openingSequence(code2) {
    if (code2 === 96) {
      effects.consume(code2);
      sizeOpen++;
      return openingSequence;
    }
    effects.exit("codeTextSequence");
    return gap(code2);
  }
  function gap(code2) {
    if (code2 === null) {
      return nok(code2);
    }
    if (code2 === 96) {
      token2 = effects.enter("codeTextSequence");
      size = 0;
      return closingSequence(code2);
    }
    if (code2 === 32) {
      effects.enter("space");
      effects.consume(code2);
      effects.exit("space");
      return gap;
    }
    if (markdownLineEnding(code2)) {
      effects.enter("lineEnding");
      effects.consume(code2);
      effects.exit("lineEnding");
      return gap;
    }
    effects.enter("codeTextData");
    return data3(code2);
  }
  function data3(code2) {
    if (code2 === null || code2 === 32 || code2 === 96 || markdownLineEnding(code2)) {
      effects.exit("codeTextData");
      return gap(code2);
    }
    effects.consume(code2);
    return data3;
  }
  function closingSequence(code2) {
    if (code2 === 96) {
      effects.consume(code2);
      size++;
      return closingSequence;
    }
    if (size === sizeOpen) {
      effects.exit("codeTextSequence");
      effects.exit("codeText");
      return ok2(code2);
    }
    token2.type = "codeTextData";
    return data3(code2);
  }
}

// node_modules/micromark-util-subtokenize/index.js
function subtokenize(events) {
  const jumps = {};
  let index2 = -1;
  let event;
  let lineIndex;
  let otherIndex;
  let otherEvent;
  let parameters;
  let subevents;
  let more;
  while (++index2 < events.length) {
    while (index2 in jumps) {
      index2 = jumps[index2];
    }
    event = events[index2];
    if (index2 && event[1].type === "chunkFlow" && events[index2 - 1][1].type === "listItemPrefix") {
      subevents = event[1]._tokenizer.events;
      otherIndex = 0;
      if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") {
        otherIndex += 2;
      }
      if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") {
        while (++otherIndex < subevents.length) {
          if (subevents[otherIndex][1].type === "content") {
            break;
          }
          if (subevents[otherIndex][1].type === "chunkText") {
            subevents[otherIndex][1]._isInFirstContentOfListItem = true;
            otherIndex++;
          }
        }
      }
    }
    if (event[0] === "enter") {
      if (event[1].contentType) {
        Object.assign(jumps, subcontent(events, index2));
        index2 = jumps[index2];
        more = true;
      }
    } else if (event[1]._container) {
      otherIndex = index2;
      lineIndex = void 0;
      while (otherIndex--) {
        otherEvent = events[otherIndex];
        if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") {
          if (otherEvent[0] === "enter") {
            if (lineIndex) {
              events[lineIndex][1].type = "lineEndingBlank";
            }
            otherEvent[1].type = "lineEnding";
            lineIndex = otherIndex;
          }
        } else {
          break;
        }
      }
      if (lineIndex) {
        event[1].end = Object.assign({}, events[lineIndex][1].start);
        parameters = events.slice(lineIndex, index2);
        parameters.unshift(event);
        splice(events, lineIndex, index2 - lineIndex + 1, parameters);
      }
    }
  }
  return !more;
}
function subcontent(events, eventIndex) {
  const token2 = events[eventIndex][1];
  const context = events[eventIndex][2];
  let startPosition = eventIndex - 1;
  const startPositions = [];
  const tokenizer4 = token2._tokenizer || context.parser[token2.contentType](token2.start);
  const childEvents = tokenizer4.events;
  const jumps = [];
  const gaps = {};
  let stream;
  let previous2;
  let index2 = -1;
  let current3 = token2;
  let adjust = 0;
  let start3 = 0;
  const breaks = [start3];
  while (current3) {
    while (events[++startPosition][1] !== current3) {
    }
    startPositions.push(startPosition);
    if (!current3._tokenizer) {
      stream = context.sliceStream(current3);
      if (!current3.next) {
        stream.push(null);
      }
      if (previous2) {
        tokenizer4.defineSkip(current3.start);
      }
      if (current3._isInFirstContentOfListItem) {
        tokenizer4._gfmTasklistFirstContentOfListItem = true;
      }
      tokenizer4.write(stream);
      if (current3._isInFirstContentOfListItem) {
        tokenizer4._gfmTasklistFirstContentOfListItem = void 0;
      }
    }
    previous2 = current3;
    current3 = current3.next;
  }
  current3 = token2;
  while (++index2 < childEvents.length) {
    if (
      // Find a void token that includes a break.
      childEvents[index2][0] === "exit" && childEvents[index2 - 1][0] === "enter" && childEvents[index2][1].type === childEvents[index2 - 1][1].type && childEvents[index2][1].start.line !== childEvents[index2][1].end.line
    ) {
      start3 = index2 + 1;
      breaks.push(start3);
      current3._tokenizer = void 0;
      current3.previous = void 0;
      current3 = current3.next;
    }
  }
  tokenizer4.events = [];
  if (current3) {
    current3._tokenizer = void 0;
    current3.previous = void 0;
  } else {
    breaks.pop();
  }
  index2 = breaks.length;
  while (index2--) {
    const slice2 = childEvents.slice(breaks[index2], breaks[index2 + 1]);
    const start4 = startPositions.pop();
    jumps.unshift([start4, start4 + slice2.length - 1]);
    splice(events, start4, 2, slice2);
  }
  index2 = -1;
  while (++index2 < jumps.length) {
    gaps[adjust + jumps[index2][0]] = adjust + jumps[index2][1];
    adjust += jumps[index2][1] - jumps[index2][0] - 1;
  }
  return gaps;
}

// node_modules/micromark-core-commonmark/lib/content.js
var content = {
  tokenize: tokenizeContent,
  resolve: resolveContent
};
var continuationConstruct = {
  tokenize: tokenizeContinuation,
  partial: true
};
function resolveContent(events) {
  subtokenize(events);
  return events;
}
function tokenizeContent(effects, ok2) {
  let previous2;
  return start3;
  function start3(code2) {
    effects.enter("content");
    previous2 = effects.enter("chunkContent", {
      contentType: "content"
    });
    return data3(code2);
  }
  function data3(code2) {
    if (code2 === null) {
      return contentEnd(code2);
    }
    if (markdownLineEnding(code2)) {
      return effects.check(
        continuationConstruct,
        contentContinue,
        contentEnd
      )(code2);
    }
    effects.consume(code2);
    return data3;
  }
  function contentEnd(code2) {
    effects.exit("chunkContent");
    effects.exit("content");
    return ok2(code2);
  }
  function contentContinue(code2) {
    effects.consume(code2);
    effects.exit("chunkContent");
    previous2.next = effects.enter("chunkContent", {
      contentType: "content",
      previous: previous2
    });
    previous2 = previous2.next;
    return data3;
  }
}
function tokenizeContinuation(effects, ok2, nok) {
  const self2 = this;
  return startLookahead;
  function startLookahead(code2) {
    effects.exit("chunkContent");
    effects.enter("lineEnding");
    effects.consume(code2);
    effects.exit("lineEnding");
    return factorySpace(effects, prefixed, "linePrefix");
  }
  function prefixed(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      return nok(code2);
    }
    const tail = self2.events[self2.events.length - 1];
    if (!self2.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4) {
      return ok2(code2);
    }
    return effects.interrupt(self2.parser.constructs.flow, nok, ok2)(code2);
  }
}

// node_modules/micromark-factory-destination/index.js
function factoryDestination(effects, ok2, nok, type, literalType, literalMarkerType, rawType, stringType, max) {
  const limit = max || Number.POSITIVE_INFINITY;
  let balance = 0;
  return start3;
  function start3(code2) {
    if (code2 === 60) {
      effects.enter(type);
      effects.enter(literalType);
      effects.enter(literalMarkerType);
      effects.consume(code2);
      effects.exit(literalMarkerType);
      return destinationEnclosedBefore;
    }
    if (code2 === null || code2 === 41 || asciiControl(code2)) {
      return nok(code2);
    }
    effects.enter(type);
    effects.enter(rawType);
    effects.enter(stringType);
    effects.enter("chunkString", {
      contentType: "string"
    });
    return destinationRaw(code2);
  }
  function destinationEnclosedBefore(code2) {
    if (code2 === 62) {
      effects.enter(literalMarkerType);
      effects.consume(code2);
      effects.exit(literalMarkerType);
      effects.exit(literalType);
      effects.exit(type);
      return ok2;
    }
    effects.enter(stringType);
    effects.enter("chunkString", {
      contentType: "string"
    });
    return destinationEnclosed(code2);
  }
  function destinationEnclosed(code2) {
    if (code2 === 62) {
      effects.exit("chunkString");
      effects.exit(stringType);
      return destinationEnclosedBefore(code2);
    }
    if (code2 === null || code2 === 60 || markdownLineEnding(code2)) {
      return nok(code2);
    }
    effects.consume(code2);
    return code2 === 92 ? destinationEnclosedEscape : destinationEnclosed;
  }
  function destinationEnclosedEscape(code2) {
    if (code2 === 60 || code2 === 62 || code2 === 92) {
      effects.consume(code2);
      return destinationEnclosed;
    }
    return destinationEnclosed(code2);
  }
  function destinationRaw(code2) {
    if (code2 === 40) {
      if (++balance > limit)
        return nok(code2);
      effects.consume(code2);
      return destinationRaw;
    }
    if (code2 === 41) {
      if (!balance--) {
        effects.exit("chunkString");
        effects.exit(stringType);
        effects.exit(rawType);
        effects.exit(type);
        return ok2(code2);
      }
      effects.consume(code2);
      return destinationRaw;
    }
    if (code2 === null || markdownLineEndingOrSpace(code2)) {
      if (balance)
        return nok(code2);
      effects.exit("chunkString");
      effects.exit(stringType);
      effects.exit(rawType);
      effects.exit(type);
      return ok2(code2);
    }
    if (asciiControl(code2))
      return nok(code2);
    effects.consume(code2);
    return code2 === 92 ? destinationRawEscape : destinationRaw;
  }
  function destinationRawEscape(code2) {
    if (code2 === 40 || code2 === 41 || code2 === 92) {
      effects.consume(code2);
      return destinationRaw;
    }
    return destinationRaw(code2);
  }
}

// node_modules/micromark-factory-label/index.js
function factoryLabel(effects, ok2, nok, type, markerType, stringType) {
  const self2 = this;
  let size = 0;
  let data3;
  return start3;
  function start3(code2) {
    effects.enter(type);
    effects.enter(markerType);
    effects.consume(code2);
    effects.exit(markerType);
    effects.enter(stringType);
    return atBreak;
  }
  function atBreak(code2) {
    if (code2 === null || code2 === 91 || code2 === 93 && !data3 || /* To do: remove in the future once we’ve switched from
     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,
     * which doesn’t need this */
    /* Hidden footnotes hook */
    /* c8 ignore next 3 */
    code2 === 94 && !size && "_hiddenFootnoteSupport" in self2.parser.constructs || size > 999) {
      return nok(code2);
    }
    if (code2 === 93) {
      effects.exit(stringType);
      effects.enter(markerType);
      effects.consume(code2);
      effects.exit(markerType);
      effects.exit(type);
      return ok2;
    }
    if (markdownLineEnding(code2)) {
      effects.enter("lineEnding");
      effects.consume(code2);
      effects.exit("lineEnding");
      return atBreak;
    }
    effects.enter("chunkString", {
      contentType: "string"
    });
    return label(code2);
  }
  function label(code2) {
    if (code2 === null || code2 === 91 || code2 === 93 || markdownLineEnding(code2) || size++ > 999) {
      effects.exit("chunkString");
      return atBreak(code2);
    }
    effects.consume(code2);
    data3 = data3 || !markdownSpace(code2);
    return code2 === 92 ? labelEscape : label;
  }
  function labelEscape(code2) {
    if (code2 === 91 || code2 === 92 || code2 === 93) {
      effects.consume(code2);
      size++;
      return label;
    }
    return label(code2);
  }
}

// node_modules/micromark-factory-title/index.js
function factoryTitle(effects, ok2, nok, type, markerType, stringType) {
  let marker;
  return start3;
  function start3(code2) {
    effects.enter(type);
    effects.enter(markerType);
    effects.consume(code2);
    effects.exit(markerType);
    marker = code2 === 40 ? 41 : code2;
    return atFirstTitleBreak;
  }
  function atFirstTitleBreak(code2) {
    if (code2 === marker) {
      effects.enter(markerType);
      effects.consume(code2);
      effects.exit(markerType);
      effects.exit(type);
      return ok2;
    }
    effects.enter(stringType);
    return atTitleBreak(code2);
  }
  function atTitleBreak(code2) {
    if (code2 === marker) {
      effects.exit(stringType);
      return atFirstTitleBreak(marker);
    }
    if (code2 === null) {
      return nok(code2);
    }
    if (markdownLineEnding(code2)) {
      effects.enter("lineEnding");
      effects.consume(code2);
      effects.exit("lineEnding");
      return factorySpace(effects, atTitleBreak, "linePrefix");
    }
    effects.enter("chunkString", {
      contentType: "string"
    });
    return title(code2);
  }
  function title(code2) {
    if (code2 === marker || code2 === null || markdownLineEnding(code2)) {
      effects.exit("chunkString");
      return atTitleBreak(code2);
    }
    effects.consume(code2);
    return code2 === 92 ? titleEscape : title;
  }
  function titleEscape(code2) {
    if (code2 === marker || code2 === 92) {
      effects.consume(code2);
      return title;
    }
    return title(code2);
  }
}

// node_modules/micromark-factory-whitespace/index.js
function factoryWhitespace(effects, ok2) {
  let seen;
  return start3;
  function start3(code2) {
    if (markdownLineEnding(code2)) {
      effects.enter("lineEnding");
      effects.consume(code2);
      effects.exit("lineEnding");
      seen = true;
      return start3;
    }
    if (markdownSpace(code2)) {
      return factorySpace(
        effects,
        start3,
        seen ? "linePrefix" : "lineSuffix"
      )(code2);
    }
    return ok2(code2);
  }
}

// node_modules/micromark-util-normalize-identifier/index.js
function normalizeIdentifier(value2) {
  return value2.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
}

// node_modules/micromark-core-commonmark/lib/definition.js
var definition = {
  name: "definition",
  tokenize: tokenizeDefinition
};
var titleConstruct = {
  tokenize: tokenizeTitle,
  partial: true
};
function tokenizeDefinition(effects, ok2, nok) {
  const self2 = this;
  let identifier;
  return start3;
  function start3(code2) {
    effects.enter("definition");
    return factoryLabel.call(
      self2,
      effects,
      labelAfter,
      nok,
      "definitionLabel",
      "definitionLabelMarker",
      "definitionLabelString"
    )(code2);
  }
  function labelAfter(code2) {
    identifier = normalizeIdentifier(
      self2.sliceSerialize(self2.events[self2.events.length - 1][1]).slice(1, -1)
    );
    if (code2 === 58) {
      effects.enter("definitionMarker");
      effects.consume(code2);
      effects.exit("definitionMarker");
      return factoryWhitespace(
        effects,
        factoryDestination(
          effects,
          effects.attempt(
            titleConstruct,
            factorySpace(effects, after, "whitespace"),
            factorySpace(effects, after, "whitespace")
          ),
          nok,
          "definitionDestination",
          "definitionDestinationLiteral",
          "definitionDestinationLiteralMarker",
          "definitionDestinationRaw",
          "definitionDestinationString"
        )
      );
    }
    return nok(code2);
  }
  function after(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("definition");
      if (!self2.parser.defined.includes(identifier)) {
        self2.parser.defined.push(identifier);
      }
      return ok2(code2);
    }
    return nok(code2);
  }
}
function tokenizeTitle(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, before)(code2) : nok(code2);
  }
  function before(code2) {
    if (code2 === 34 || code2 === 39 || code2 === 40) {
      return factoryTitle(
        effects,
        factorySpace(effects, after, "whitespace"),
        nok,
        "definitionTitle",
        "definitionTitleMarker",
        "definitionTitleString"
      )(code2);
    }
    return nok(code2);
  }
  function after(code2) {
    return code2 === null || markdownLineEnding(code2) ? ok2(code2) : nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/hard-break-escape.js
var hardBreakEscape = {
  name: "hardBreakEscape",
  tokenize: tokenizeHardBreakEscape
};
function tokenizeHardBreakEscape(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    effects.enter("hardBreakEscape");
    effects.enter("escapeMarker");
    effects.consume(code2);
    return open;
  }
  function open(code2) {
    if (markdownLineEnding(code2)) {
      effects.exit("escapeMarker");
      effects.exit("hardBreakEscape");
      return ok2(code2);
    }
    return nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/heading-atx.js
var headingAtx = {
  name: "headingAtx",
  tokenize: tokenizeHeadingAtx,
  resolve: resolveHeadingAtx
};
function resolveHeadingAtx(events, context) {
  let contentEnd = events.length - 2;
  let contentStart = 3;
  let content3;
  let text5;
  if (events[contentStart][1].type === "whitespace") {
    contentStart += 2;
  }
  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") {
    contentEnd -= 2;
  }
  if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) {
    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
  }
  if (contentEnd > contentStart) {
    content3 = {
      type: "atxHeadingText",
      start: events[contentStart][1].start,
      end: events[contentEnd][1].end
    };
    text5 = {
      type: "chunkText",
      start: events[contentStart][1].start,
      end: events[contentEnd][1].end,
      // @ts-expect-error Constants are fine to assign.
      contentType: "text"
    };
    splice(events, contentStart, contentEnd - contentStart + 1, [
      ["enter", content3, context],
      ["enter", text5, context],
      ["exit", text5, context],
      ["exit", content3, context]
    ]);
  }
  return events;
}
function tokenizeHeadingAtx(effects, ok2, nok) {
  const self2 = this;
  let size = 0;
  return start3;
  function start3(code2) {
    effects.enter("atxHeading");
    effects.enter("atxHeadingSequence");
    return fenceOpenInside(code2);
  }
  function fenceOpenInside(code2) {
    if (code2 === 35 && size++ < 6) {
      effects.consume(code2);
      return fenceOpenInside;
    }
    if (code2 === null || markdownLineEndingOrSpace(code2)) {
      effects.exit("atxHeadingSequence");
      return self2.interrupt ? ok2(code2) : headingBreak(code2);
    }
    return nok(code2);
  }
  function headingBreak(code2) {
    if (code2 === 35) {
      effects.enter("atxHeadingSequence");
      return sequence(code2);
    }
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("atxHeading");
      return ok2(code2);
    }
    if (markdownSpace(code2)) {
      return factorySpace(effects, headingBreak, "whitespace")(code2);
    }
    effects.enter("atxHeadingText");
    return data3(code2);
  }
  function sequence(code2) {
    if (code2 === 35) {
      effects.consume(code2);
      return sequence;
    }
    effects.exit("atxHeadingSequence");
    return headingBreak(code2);
  }
  function data3(code2) {
    if (code2 === null || code2 === 35 || markdownLineEndingOrSpace(code2)) {
      effects.exit("atxHeadingText");
      return headingBreak(code2);
    }
    effects.consume(code2);
    return data3;
  }
}

// node_modules/micromark-util-html-tag-name/index.js
var htmlBlockNames = [
  "address",
  "article",
  "aside",
  "base",
  "basefont",
  "blockquote",
  "body",
  "caption",
  "center",
  "col",
  "colgroup",
  "dd",
  "details",
  "dialog",
  "dir",
  "div",
  "dl",
  "dt",
  "fieldset",
  "figcaption",
  "figure",
  "footer",
  "form",
  "frame",
  "frameset",
  "h1",
  "h2",
  "h3",
  "h4",
  "h5",
  "h6",
  "head",
  "header",
  "hr",
  "html",
  "iframe",
  "legend",
  "li",
  "link",
  "main",
  "menu",
  "menuitem",
  "nav",
  "noframes",
  "ol",
  "optgroup",
  "option",
  "p",
  "param",
  "section",
  "summary",
  "table",
  "tbody",
  "td",
  "tfoot",
  "th",
  "thead",
  "title",
  "tr",
  "track",
  "ul"
];
var htmlRawNames = ["pre", "script", "style", "textarea"];

// node_modules/micromark-core-commonmark/lib/html-flow.js
var htmlFlow = {
  name: "htmlFlow",
  tokenize: tokenizeHtmlFlow,
  resolveTo: resolveToHtmlFlow,
  concrete: true
};
var nextBlankConstruct = {
  tokenize: tokenizeNextBlank,
  partial: true
};
function resolveToHtmlFlow(events) {
  let index2 = events.length;
  while (index2--) {
    if (events[index2][0] === "enter" && events[index2][1].type === "htmlFlow") {
      break;
    }
  }
  if (index2 > 1 && events[index2 - 2][1].type === "linePrefix") {
    events[index2][1].start = events[index2 - 2][1].start;
    events[index2 + 1][1].start = events[index2 - 2][1].start;
    events.splice(index2 - 2, 2);
  }
  return events;
}
function tokenizeHtmlFlow(effects, ok2, nok) {
  const self2 = this;
  let kind;
  let startTag;
  let buffer3;
  let index2;
  let marker;
  return start3;
  function start3(code2) {
    effects.enter("htmlFlow");
    effects.enter("htmlFlowData");
    effects.consume(code2);
    return open;
  }
  function open(code2) {
    if (code2 === 33) {
      effects.consume(code2);
      return declarationStart;
    }
    if (code2 === 47) {
      effects.consume(code2);
      return tagCloseStart;
    }
    if (code2 === 63) {
      effects.consume(code2);
      kind = 3;
      return self2.interrupt ? ok2 : continuationDeclarationInside;
    }
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      buffer3 = String.fromCharCode(code2);
      startTag = true;
      return tagName;
    }
    return nok(code2);
  }
  function declarationStart(code2) {
    if (code2 === 45) {
      effects.consume(code2);
      kind = 2;
      return commentOpenInside;
    }
    if (code2 === 91) {
      effects.consume(code2);
      kind = 5;
      buffer3 = "CDATA[";
      index2 = 0;
      return cdataOpenInside;
    }
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      kind = 4;
      return self2.interrupt ? ok2 : continuationDeclarationInside;
    }
    return nok(code2);
  }
  function commentOpenInside(code2) {
    if (code2 === 45) {
      effects.consume(code2);
      return self2.interrupt ? ok2 : continuationDeclarationInside;
    }
    return nok(code2);
  }
  function cdataOpenInside(code2) {
    if (code2 === buffer3.charCodeAt(index2++)) {
      effects.consume(code2);
      return index2 === buffer3.length ? self2.interrupt ? ok2 : continuation : cdataOpenInside;
    }
    return nok(code2);
  }
  function tagCloseStart(code2) {
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      buffer3 = String.fromCharCode(code2);
      return tagName;
    }
    return nok(code2);
  }
  function tagName(code2) {
    if (code2 === null || code2 === 47 || code2 === 62 || markdownLineEndingOrSpace(code2)) {
      if (code2 !== 47 && startTag && htmlRawNames.includes(buffer3.toLowerCase())) {
        kind = 1;
        return self2.interrupt ? ok2(code2) : continuation(code2);
      }
      if (htmlBlockNames.includes(buffer3.toLowerCase())) {
        kind = 6;
        if (code2 === 47) {
          effects.consume(code2);
          return basicSelfClosing;
        }
        return self2.interrupt ? ok2(code2) : continuation(code2);
      }
      kind = 7;
      return self2.interrupt && !self2.parser.lazy[self2.now().line] ? nok(code2) : startTag ? completeAttributeNameBefore(code2) : completeClosingTagAfter(code2);
    }
    if (code2 === 45 || asciiAlphanumeric(code2)) {
      effects.consume(code2);
      buffer3 += String.fromCharCode(code2);
      return tagName;
    }
    return nok(code2);
  }
  function basicSelfClosing(code2) {
    if (code2 === 62) {
      effects.consume(code2);
      return self2.interrupt ? ok2 : continuation;
    }
    return nok(code2);
  }
  function completeClosingTagAfter(code2) {
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return completeClosingTagAfter;
    }
    return completeEnd(code2);
  }
  function completeAttributeNameBefore(code2) {
    if (code2 === 47) {
      effects.consume(code2);
      return completeEnd;
    }
    if (code2 === 58 || code2 === 95 || asciiAlpha(code2)) {
      effects.consume(code2);
      return completeAttributeName;
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return completeAttributeNameBefore;
    }
    return completeEnd(code2);
  }
  function completeAttributeName(code2) {
    if (code2 === 45 || code2 === 46 || code2 === 58 || code2 === 95 || asciiAlphanumeric(code2)) {
      effects.consume(code2);
      return completeAttributeName;
    }
    return completeAttributeNameAfter(code2);
  }
  function completeAttributeNameAfter(code2) {
    if (code2 === 61) {
      effects.consume(code2);
      return completeAttributeValueBefore;
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return completeAttributeNameAfter;
    }
    return completeAttributeNameBefore(code2);
  }
  function completeAttributeValueBefore(code2) {
    if (code2 === null || code2 === 60 || code2 === 61 || code2 === 62 || code2 === 96) {
      return nok(code2);
    }
    if (code2 === 34 || code2 === 39) {
      effects.consume(code2);
      marker = code2;
      return completeAttributeValueQuoted;
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return completeAttributeValueBefore;
    }
    marker = null;
    return completeAttributeValueUnquoted(code2);
  }
  function completeAttributeValueQuoted(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      return nok(code2);
    }
    if (code2 === marker) {
      effects.consume(code2);
      return completeAttributeValueQuotedAfter;
    }
    effects.consume(code2);
    return completeAttributeValueQuoted;
  }
  function completeAttributeValueUnquoted(code2) {
    if (code2 === null || code2 === 34 || code2 === 39 || code2 === 60 || code2 === 61 || code2 === 62 || code2 === 96 || markdownLineEndingOrSpace(code2)) {
      return completeAttributeNameAfter(code2);
    }
    effects.consume(code2);
    return completeAttributeValueUnquoted;
  }
  function completeAttributeValueQuotedAfter(code2) {
    if (code2 === 47 || code2 === 62 || markdownSpace(code2)) {
      return completeAttributeNameBefore(code2);
    }
    return nok(code2);
  }
  function completeEnd(code2) {
    if (code2 === 62) {
      effects.consume(code2);
      return completeAfter;
    }
    return nok(code2);
  }
  function completeAfter(code2) {
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return completeAfter;
    }
    return code2 === null || markdownLineEnding(code2) ? continuation(code2) : nok(code2);
  }
  function continuation(code2) {
    if (code2 === 45 && kind === 2) {
      effects.consume(code2);
      return continuationCommentInside;
    }
    if (code2 === 60 && kind === 1) {
      effects.consume(code2);
      return continuationRawTagOpen;
    }
    if (code2 === 62 && kind === 4) {
      effects.consume(code2);
      return continuationClose;
    }
    if (code2 === 63 && kind === 3) {
      effects.consume(code2);
      return continuationDeclarationInside;
    }
    if (code2 === 93 && kind === 5) {
      effects.consume(code2);
      return continuationCharacterDataInside;
    }
    if (markdownLineEnding(code2) && (kind === 6 || kind === 7)) {
      return effects.check(
        nextBlankConstruct,
        continuationClose,
        continuationAtLineEnding
      )(code2);
    }
    if (code2 === null || markdownLineEnding(code2)) {
      return continuationAtLineEnding(code2);
    }
    effects.consume(code2);
    return continuation;
  }
  function continuationAtLineEnding(code2) {
    effects.exit("htmlFlowData");
    return htmlContinueStart(code2);
  }
  function htmlContinueStart(code2) {
    if (code2 === null) {
      return done(code2);
    }
    if (markdownLineEnding(code2)) {
      return effects.attempt(
        {
          tokenize: htmlLineEnd,
          partial: true
        },
        htmlContinueStart,
        done
      )(code2);
    }
    effects.enter("htmlFlowData");
    return continuation(code2);
  }
  function htmlLineEnd(effects2, ok3, nok2) {
    return start4;
    function start4(code2) {
      effects2.enter("lineEnding");
      effects2.consume(code2);
      effects2.exit("lineEnding");
      return lineStart;
    }
    function lineStart(code2) {
      return self2.parser.lazy[self2.now().line] ? nok2(code2) : ok3(code2);
    }
  }
  function continuationCommentInside(code2) {
    if (code2 === 45) {
      effects.consume(code2);
      return continuationDeclarationInside;
    }
    return continuation(code2);
  }
  function continuationRawTagOpen(code2) {
    if (code2 === 47) {
      effects.consume(code2);
      buffer3 = "";
      return continuationRawEndTag;
    }
    return continuation(code2);
  }
  function continuationRawEndTag(code2) {
    if (code2 === 62 && htmlRawNames.includes(buffer3.toLowerCase())) {
      effects.consume(code2);
      return continuationClose;
    }
    if (asciiAlpha(code2) && buffer3.length < 8) {
      effects.consume(code2);
      buffer3 += String.fromCharCode(code2);
      return continuationRawEndTag;
    }
    return continuation(code2);
  }
  function continuationCharacterDataInside(code2) {
    if (code2 === 93) {
      effects.consume(code2);
      return continuationDeclarationInside;
    }
    return continuation(code2);
  }
  function continuationDeclarationInside(code2) {
    if (code2 === 62) {
      effects.consume(code2);
      return continuationClose;
    }
    if (code2 === 45 && kind === 2) {
      effects.consume(code2);
      return continuationDeclarationInside;
    }
    return continuation(code2);
  }
  function continuationClose(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("htmlFlowData");
      return done(code2);
    }
    effects.consume(code2);
    return continuationClose;
  }
  function done(code2) {
    effects.exit("htmlFlow");
    return ok2(code2);
  }
}
function tokenizeNextBlank(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    effects.exit("htmlFlowData");
    effects.enter("lineEndingBlank");
    effects.consume(code2);
    effects.exit("lineEndingBlank");
    return effects.attempt(blankLine, ok2, nok);
  }
}

// node_modules/micromark-core-commonmark/lib/html-text.js
var htmlText = {
  name: "htmlText",
  tokenize: tokenizeHtmlText
};
function tokenizeHtmlText(effects, ok2, nok) {
  const self2 = this;
  let marker;
  let buffer3;
  let index2;
  let returnState;
  return start3;
  function start3(code2) {
    effects.enter("htmlText");
    effects.enter("htmlTextData");
    effects.consume(code2);
    return open;
  }
  function open(code2) {
    if (code2 === 33) {
      effects.consume(code2);
      return declarationOpen;
    }
    if (code2 === 47) {
      effects.consume(code2);
      return tagCloseStart;
    }
    if (code2 === 63) {
      effects.consume(code2);
      return instruction;
    }
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      return tagOpen;
    }
    return nok(code2);
  }
  function declarationOpen(code2) {
    if (code2 === 45) {
      effects.consume(code2);
      return commentOpen;
    }
    if (code2 === 91) {
      effects.consume(code2);
      buffer3 = "CDATA[";
      index2 = 0;
      return cdataOpen;
    }
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      return declaration;
    }
    return nok(code2);
  }
  function commentOpen(code2) {
    if (code2 === 45) {
      effects.consume(code2);
      return commentStart;
    }
    return nok(code2);
  }
  function commentStart(code2) {
    if (code2 === null || code2 === 62) {
      return nok(code2);
    }
    if (code2 === 45) {
      effects.consume(code2);
      return commentStartDash;
    }
    return comment2(code2);
  }
  function commentStartDash(code2) {
    if (code2 === null || code2 === 62) {
      return nok(code2);
    }
    return comment2(code2);
  }
  function comment2(code2) {
    if (code2 === null) {
      return nok(code2);
    }
    if (code2 === 45) {
      effects.consume(code2);
      return commentClose;
    }
    if (markdownLineEnding(code2)) {
      returnState = comment2;
      return atLineEnding(code2);
    }
    effects.consume(code2);
    return comment2;
  }
  function commentClose(code2) {
    if (code2 === 45) {
      effects.consume(code2);
      return end;
    }
    return comment2(code2);
  }
  function cdataOpen(code2) {
    if (code2 === buffer3.charCodeAt(index2++)) {
      effects.consume(code2);
      return index2 === buffer3.length ? cdata : cdataOpen;
    }
    return nok(code2);
  }
  function cdata(code2) {
    if (code2 === null) {
      return nok(code2);
    }
    if (code2 === 93) {
      effects.consume(code2);
      return cdataClose;
    }
    if (markdownLineEnding(code2)) {
      returnState = cdata;
      return atLineEnding(code2);
    }
    effects.consume(code2);
    return cdata;
  }
  function cdataClose(code2) {
    if (code2 === 93) {
      effects.consume(code2);
      return cdataEnd;
    }
    return cdata(code2);
  }
  function cdataEnd(code2) {
    if (code2 === 62) {
      return end(code2);
    }
    if (code2 === 93) {
      effects.consume(code2);
      return cdataEnd;
    }
    return cdata(code2);
  }
  function declaration(code2) {
    if (code2 === null || code2 === 62) {
      return end(code2);
    }
    if (markdownLineEnding(code2)) {
      returnState = declaration;
      return atLineEnding(code2);
    }
    effects.consume(code2);
    return declaration;
  }
  function instruction(code2) {
    if (code2 === null) {
      return nok(code2);
    }
    if (code2 === 63) {
      effects.consume(code2);
      return instructionClose;
    }
    if (markdownLineEnding(code2)) {
      returnState = instruction;
      return atLineEnding(code2);
    }
    effects.consume(code2);
    return instruction;
  }
  function instructionClose(code2) {
    return code2 === 62 ? end(code2) : instruction(code2);
  }
  function tagCloseStart(code2) {
    if (asciiAlpha(code2)) {
      effects.consume(code2);
      return tagClose;
    }
    return nok(code2);
  }
  function tagClose(code2) {
    if (code2 === 45 || asciiAlphanumeric(code2)) {
      effects.consume(code2);
      return tagClose;
    }
    return tagCloseBetween(code2);
  }
  function tagCloseBetween(code2) {
    if (markdownLineEnding(code2)) {
      returnState = tagCloseBetween;
      return atLineEnding(code2);
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return tagCloseBetween;
    }
    return end(code2);
  }
  function tagOpen(code2) {
    if (code2 === 45 || asciiAlphanumeric(code2)) {
      effects.consume(code2);
      return tagOpen;
    }
    if (code2 === 47 || code2 === 62 || markdownLineEndingOrSpace(code2)) {
      return tagOpenBetween(code2);
    }
    return nok(code2);
  }
  function tagOpenBetween(code2) {
    if (code2 === 47) {
      effects.consume(code2);
      return end;
    }
    if (code2 === 58 || code2 === 95 || asciiAlpha(code2)) {
      effects.consume(code2);
      return tagOpenAttributeName;
    }
    if (markdownLineEnding(code2)) {
      returnState = tagOpenBetween;
      return atLineEnding(code2);
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return tagOpenBetween;
    }
    return end(code2);
  }
  function tagOpenAttributeName(code2) {
    if (code2 === 45 || code2 === 46 || code2 === 58 || code2 === 95 || asciiAlphanumeric(code2)) {
      effects.consume(code2);
      return tagOpenAttributeName;
    }
    return tagOpenAttributeNameAfter(code2);
  }
  function tagOpenAttributeNameAfter(code2) {
    if (code2 === 61) {
      effects.consume(code2);
      return tagOpenAttributeValueBefore;
    }
    if (markdownLineEnding(code2)) {
      returnState = tagOpenAttributeNameAfter;
      return atLineEnding(code2);
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return tagOpenAttributeNameAfter;
    }
    return tagOpenBetween(code2);
  }
  function tagOpenAttributeValueBefore(code2) {
    if (code2 === null || code2 === 60 || code2 === 61 || code2 === 62 || code2 === 96) {
      return nok(code2);
    }
    if (code2 === 34 || code2 === 39) {
      effects.consume(code2);
      marker = code2;
      return tagOpenAttributeValueQuoted;
    }
    if (markdownLineEnding(code2)) {
      returnState = tagOpenAttributeValueBefore;
      return atLineEnding(code2);
    }
    if (markdownSpace(code2)) {
      effects.consume(code2);
      return tagOpenAttributeValueBefore;
    }
    effects.consume(code2);
    marker = void 0;
    return tagOpenAttributeValueUnquoted;
  }
  function tagOpenAttributeValueQuoted(code2) {
    if (code2 === marker) {
      effects.consume(code2);
      return tagOpenAttributeValueQuotedAfter;
    }
    if (code2 === null) {
      return nok(code2);
    }
    if (markdownLineEnding(code2)) {
      returnState = tagOpenAttributeValueQuoted;
      return atLineEnding(code2);
    }
    effects.consume(code2);
    return tagOpenAttributeValueQuoted;
  }
  function tagOpenAttributeValueQuotedAfter(code2) {
    if (code2 === 62 || code2 === 47 || markdownLineEndingOrSpace(code2)) {
      return tagOpenBetween(code2);
    }
    return nok(code2);
  }
  function tagOpenAttributeValueUnquoted(code2) {
    if (code2 === null || code2 === 34 || code2 === 39 || code2 === 60 || code2 === 61 || code2 === 96) {
      return nok(code2);
    }
    if (code2 === 62 || markdownLineEndingOrSpace(code2)) {
      return tagOpenBetween(code2);
    }
    effects.consume(code2);
    return tagOpenAttributeValueUnquoted;
  }
  function atLineEnding(code2) {
    effects.exit("htmlTextData");
    effects.enter("lineEnding");
    effects.consume(code2);
    effects.exit("lineEnding");
    return factorySpace(
      effects,
      afterPrefix,
      "linePrefix",
      self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4
    );
  }
  function afterPrefix(code2) {
    effects.enter("htmlTextData");
    return returnState(code2);
  }
  function end(code2) {
    if (code2 === 62) {
      effects.consume(code2);
      effects.exit("htmlTextData");
      effects.exit("htmlText");
      return ok2;
    }
    return nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/label-end.js
var labelEnd = {
  name: "labelEnd",
  tokenize: tokenizeLabelEnd,
  resolveTo: resolveToLabelEnd,
  resolveAll: resolveAllLabelEnd
};
var resourceConstruct = {
  tokenize: tokenizeResource
};
var fullReferenceConstruct = {
  tokenize: tokenizeFullReference
};
var collapsedReferenceConstruct = {
  tokenize: tokenizeCollapsedReference
};
function resolveAllLabelEnd(events) {
  let index2 = -1;
  let token2;
  while (++index2 < events.length) {
    token2 = events[index2][1];
    if (token2.type === "labelImage" || token2.type === "labelLink" || token2.type === "labelEnd") {
      events.splice(index2 + 1, token2.type === "labelImage" ? 4 : 2);
      token2.type = "data";
      index2++;
    }
  }
  return events;
}
function resolveToLabelEnd(events, context) {
  let index2 = events.length;
  let offset3 = 0;
  let token2;
  let open;
  let close;
  let media;
  while (index2--) {
    token2 = events[index2][1];
    if (open) {
      if (token2.type === "link" || token2.type === "labelLink" && token2._inactive) {
        break;
      }
      if (events[index2][0] === "enter" && token2.type === "labelLink") {
        token2._inactive = true;
      }
    } else if (close) {
      if (events[index2][0] === "enter" && (token2.type === "labelImage" || token2.type === "labelLink") && !token2._balanced) {
        open = index2;
        if (token2.type !== "labelLink") {
          offset3 = 2;
          break;
        }
      }
    } else if (token2.type === "labelEnd") {
      close = index2;
    }
  }
  const group = {
    type: events[open][1].type === "labelLink" ? "link" : "image",
    start: Object.assign({}, events[open][1].start),
    end: Object.assign({}, events[events.length - 1][1].end)
  };
  const label = {
    type: "label",
    start: Object.assign({}, events[open][1].start),
    end: Object.assign({}, events[close][1].end)
  };
  const text5 = {
    type: "labelText",
    start: Object.assign({}, events[open + offset3 + 2][1].end),
    end: Object.assign({}, events[close - 2][1].start)
  };
  media = [
    ["enter", group, context],
    ["enter", label, context]
  ];
  media = push(media, events.slice(open + 1, open + offset3 + 3));
  media = push(media, [["enter", text5, context]]);
  media = push(
    media,
    resolveAll(
      context.parser.constructs.insideSpan.null,
      events.slice(open + offset3 + 4, close - 3),
      context
    )
  );
  media = push(media, [
    ["exit", text5, context],
    events[close - 2],
    events[close - 1],
    ["exit", label, context]
  ]);
  media = push(media, events.slice(close + 1));
  media = push(media, [["exit", group, context]]);
  splice(events, open, events.length, media);
  return events;
}
function tokenizeLabelEnd(effects, ok2, nok) {
  const self2 = this;
  let index2 = self2.events.length;
  let labelStart;
  let defined;
  while (index2--) {
    if ((self2.events[index2][1].type === "labelImage" || self2.events[index2][1].type === "labelLink") && !self2.events[index2][1]._balanced) {
      labelStart = self2.events[index2][1];
      break;
    }
  }
  return start3;
  function start3(code2) {
    if (!labelStart) {
      return nok(code2);
    }
    if (labelStart._inactive)
      return balanced(code2);
    defined = self2.parser.defined.includes(
      normalizeIdentifier(
        self2.sliceSerialize({
          start: labelStart.end,
          end: self2.now()
        })
      )
    );
    effects.enter("labelEnd");
    effects.enter("labelMarker");
    effects.consume(code2);
    effects.exit("labelMarker");
    effects.exit("labelEnd");
    return afterLabelEnd;
  }
  function afterLabelEnd(code2) {
    if (code2 === 40) {
      return effects.attempt(
        resourceConstruct,
        ok2,
        defined ? ok2 : balanced
      )(code2);
    }
    if (code2 === 91) {
      return effects.attempt(
        fullReferenceConstruct,
        ok2,
        defined ? effects.attempt(collapsedReferenceConstruct, ok2, balanced) : balanced
      )(code2);
    }
    return defined ? ok2(code2) : balanced(code2);
  }
  function balanced(code2) {
    labelStart._balanced = true;
    return nok(code2);
  }
}
function tokenizeResource(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    effects.enter("resource");
    effects.enter("resourceMarker");
    effects.consume(code2);
    effects.exit("resourceMarker");
    return factoryWhitespace(effects, open);
  }
  function open(code2) {
    if (code2 === 41) {
      return end(code2);
    }
    return factoryDestination(
      effects,
      destinationAfter,
      nok,
      "resourceDestination",
      "resourceDestinationLiteral",
      "resourceDestinationLiteralMarker",
      "resourceDestinationRaw",
      "resourceDestinationString",
      32
    )(code2);
  }
  function destinationAfter(code2) {
    return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, between2)(code2) : end(code2);
  }
  function between2(code2) {
    if (code2 === 34 || code2 === 39 || code2 === 40) {
      return factoryTitle(
        effects,
        factoryWhitespace(effects, end),
        nok,
        "resourceTitle",
        "resourceTitleMarker",
        "resourceTitleString"
      )(code2);
    }
    return end(code2);
  }
  function end(code2) {
    if (code2 === 41) {
      effects.enter("resourceMarker");
      effects.consume(code2);
      effects.exit("resourceMarker");
      effects.exit("resource");
      return ok2;
    }
    return nok(code2);
  }
}
function tokenizeFullReference(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    return factoryLabel.call(
      self2,
      effects,
      afterLabel,
      nok,
      "reference",
      "referenceMarker",
      "referenceString"
    )(code2);
  }
  function afterLabel(code2) {
    return self2.parser.defined.includes(
      normalizeIdentifier(
        self2.sliceSerialize(self2.events[self2.events.length - 1][1]).slice(1, -1)
      )
    ) ? ok2(code2) : nok(code2);
  }
}
function tokenizeCollapsedReference(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    effects.enter("reference");
    effects.enter("referenceMarker");
    effects.consume(code2);
    effects.exit("referenceMarker");
    return open;
  }
  function open(code2) {
    if (code2 === 93) {
      effects.enter("referenceMarker");
      effects.consume(code2);
      effects.exit("referenceMarker");
      effects.exit("reference");
      return ok2;
    }
    return nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/label-start-image.js
var labelStartImage = {
  name: "labelStartImage",
  tokenize: tokenizeLabelStartImage,
  resolveAll: labelEnd.resolveAll
};
function tokenizeLabelStartImage(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    effects.enter("labelImage");
    effects.enter("labelImageMarker");
    effects.consume(code2);
    effects.exit("labelImageMarker");
    return open;
  }
  function open(code2) {
    if (code2 === 91) {
      effects.enter("labelMarker");
      effects.consume(code2);
      effects.exit("labelMarker");
      effects.exit("labelImage");
      return after;
    }
    return nok(code2);
  }
  function after(code2) {
    return code2 === 94 && "_hiddenFootnoteSupport" in self2.parser.constructs ? nok(code2) : ok2(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/label-start-link.js
var labelStartLink = {
  name: "labelStartLink",
  tokenize: tokenizeLabelStartLink,
  resolveAll: labelEnd.resolveAll
};
function tokenizeLabelStartLink(effects, ok2, nok) {
  const self2 = this;
  return start3;
  function start3(code2) {
    effects.enter("labelLink");
    effects.enter("labelMarker");
    effects.consume(code2);
    effects.exit("labelMarker");
    effects.exit("labelLink");
    return after;
  }
  function after(code2) {
    return code2 === 94 && "_hiddenFootnoteSupport" in self2.parser.constructs ? nok(code2) : ok2(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/line-ending.js
var lineEnding = {
  name: "lineEnding",
  tokenize: tokenizeLineEnding
};
function tokenizeLineEnding(effects, ok2) {
  return start3;
  function start3(code2) {
    effects.enter("lineEnding");
    effects.consume(code2);
    effects.exit("lineEnding");
    return factorySpace(effects, ok2, "linePrefix");
  }
}

// node_modules/micromark-core-commonmark/lib/thematic-break.js
var thematicBreak = {
  name: "thematicBreak",
  tokenize: tokenizeThematicBreak
};
function tokenizeThematicBreak(effects, ok2, nok) {
  let size = 0;
  let marker;
  return start3;
  function start3(code2) {
    effects.enter("thematicBreak");
    marker = code2;
    return atBreak(code2);
  }
  function atBreak(code2) {
    if (code2 === marker) {
      effects.enter("thematicBreakSequence");
      return sequence(code2);
    }
    if (markdownSpace(code2)) {
      return factorySpace(effects, atBreak, "whitespace")(code2);
    }
    if (size < 3 || code2 !== null && !markdownLineEnding(code2)) {
      return nok(code2);
    }
    effects.exit("thematicBreak");
    return ok2(code2);
  }
  function sequence(code2) {
    if (code2 === marker) {
      effects.consume(code2);
      size++;
      return sequence;
    }
    effects.exit("thematicBreakSequence");
    return atBreak(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/list.js
var list = {
  name: "list",
  tokenize: tokenizeListStart,
  continuation: {
    tokenize: tokenizeListContinuation
  },
  exit: tokenizeListEnd
};
var listItemPrefixWhitespaceConstruct = {
  tokenize: tokenizeListItemPrefixWhitespace,
  partial: true
};
var indentConstruct = {
  tokenize: tokenizeIndent,
  partial: true
};
function tokenizeListStart(effects, ok2, nok) {
  const self2 = this;
  const tail = self2.events[self2.events.length - 1];
  let initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
  let size = 0;
  return start3;
  function start3(code2) {
    const kind = self2.containerState.type || (code2 === 42 || code2 === 43 || code2 === 45 ? "listUnordered" : "listOrdered");
    if (kind === "listUnordered" ? !self2.containerState.marker || code2 === self2.containerState.marker : asciiDigit(code2)) {
      if (!self2.containerState.type) {
        self2.containerState.type = kind;
        effects.enter(kind, {
          _container: true
        });
      }
      if (kind === "listUnordered") {
        effects.enter("listItemPrefix");
        return code2 === 42 || code2 === 45 ? effects.check(thematicBreak, nok, atMarker)(code2) : atMarker(code2);
      }
      if (!self2.interrupt || code2 === 49) {
        effects.enter("listItemPrefix");
        effects.enter("listItemValue");
        return inside(code2);
      }
    }
    return nok(code2);
  }
  function inside(code2) {
    if (asciiDigit(code2) && ++size < 10) {
      effects.consume(code2);
      return inside;
    }
    if ((!self2.interrupt || size < 2) && (self2.containerState.marker ? code2 === self2.containerState.marker : code2 === 41 || code2 === 46)) {
      effects.exit("listItemValue");
      return atMarker(code2);
    }
    return nok(code2);
  }
  function atMarker(code2) {
    effects.enter("listItemMarker");
    effects.consume(code2);
    effects.exit("listItemMarker");
    self2.containerState.marker = self2.containerState.marker || code2;
    return effects.check(
      blankLine,
      // Can’t be empty when interrupting.
      self2.interrupt ? nok : onBlank,
      effects.attempt(
        listItemPrefixWhitespaceConstruct,
        endOfPrefix,
        otherPrefix
      )
    );
  }
  function onBlank(code2) {
    self2.containerState.initialBlankLine = true;
    initialSize++;
    return endOfPrefix(code2);
  }
  function otherPrefix(code2) {
    if (markdownSpace(code2)) {
      effects.enter("listItemPrefixWhitespace");
      effects.consume(code2);
      effects.exit("listItemPrefixWhitespace");
      return endOfPrefix;
    }
    return nok(code2);
  }
  function endOfPrefix(code2) {
    self2.containerState.size = initialSize + self2.sliceSerialize(effects.exit("listItemPrefix"), true).length;
    return ok2(code2);
  }
}
function tokenizeListContinuation(effects, ok2, nok) {
  const self2 = this;
  self2.containerState._closeFlow = void 0;
  return effects.check(blankLine, onBlank, notBlank);
  function onBlank(code2) {
    self2.containerState.furtherBlankLines = self2.containerState.furtherBlankLines || self2.containerState.initialBlankLine;
    return factorySpace(
      effects,
      ok2,
      "listItemIndent",
      self2.containerState.size + 1
    )(code2);
  }
  function notBlank(code2) {
    if (self2.containerState.furtherBlankLines || !markdownSpace(code2)) {
      self2.containerState.furtherBlankLines = void 0;
      self2.containerState.initialBlankLine = void 0;
      return notInCurrentItem(code2);
    }
    self2.containerState.furtherBlankLines = void 0;
    self2.containerState.initialBlankLine = void 0;
    return effects.attempt(indentConstruct, ok2, notInCurrentItem)(code2);
  }
  function notInCurrentItem(code2) {
    self2.containerState._closeFlow = true;
    self2.interrupt = void 0;
    return factorySpace(
      effects,
      effects.attempt(list, ok2, nok),
      "linePrefix",
      self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4
    )(code2);
  }
}
function tokenizeIndent(effects, ok2, nok) {
  const self2 = this;
  return factorySpace(
    effects,
    afterPrefix,
    "listItemIndent",
    self2.containerState.size + 1
  );
  function afterPrefix(code2) {
    const tail = self2.events[self2.events.length - 1];
    return tail && tail[1].type === "listItemIndent" && tail[2].sliceSerialize(tail[1], true).length === self2.containerState.size ? ok2(code2) : nok(code2);
  }
}
function tokenizeListEnd(effects) {
  effects.exit(this.containerState.type);
}
function tokenizeListItemPrefixWhitespace(effects, ok2, nok) {
  const self2 = this;
  return factorySpace(
    effects,
    afterPrefix,
    "listItemPrefixWhitespace",
    self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 + 1
  );
  function afterPrefix(code2) {
    const tail = self2.events[self2.events.length - 1];
    return !markdownSpace(code2) && tail && tail[1].type === "listItemPrefixWhitespace" ? ok2(code2) : nok(code2);
  }
}

// node_modules/micromark-core-commonmark/lib/setext-underline.js
var setextUnderline = {
  name: "setextUnderline",
  tokenize: tokenizeSetextUnderline,
  resolveTo: resolveToSetextUnderline
};
function resolveToSetextUnderline(events, context) {
  let index2 = events.length;
  let content3;
  let text5;
  let definition2;
  while (index2--) {
    if (events[index2][0] === "enter") {
      if (events[index2][1].type === "content") {
        content3 = index2;
        break;
      }
      if (events[index2][1].type === "paragraph") {
        text5 = index2;
      }
    } else {
      if (events[index2][1].type === "content") {
        events.splice(index2, 1);
      }
      if (!definition2 && events[index2][1].type === "definition") {
        definition2 = index2;
      }
    }
  }
  const heading2 = {
    type: "setextHeading",
    start: Object.assign({}, events[text5][1].start),
    end: Object.assign({}, events[events.length - 1][1].end)
  };
  events[text5][1].type = "setextHeadingText";
  if (definition2) {
    events.splice(text5, 0, ["enter", heading2, context]);
    events.splice(definition2 + 1, 0, ["exit", events[content3][1], context]);
    events[content3][1].end = Object.assign({}, events[definition2][1].end);
  } else {
    events[content3][1] = heading2;
  }
  events.push(["exit", heading2, context]);
  return events;
}
function tokenizeSetextUnderline(effects, ok2, nok) {
  const self2 = this;
  let index2 = self2.events.length;
  let marker;
  let paragraph2;
  while (index2--) {
    if (self2.events[index2][1].type !== "lineEnding" && self2.events[index2][1].type !== "linePrefix" && self2.events[index2][1].type !== "content") {
      paragraph2 = self2.events[index2][1].type === "paragraph";
      break;
    }
  }
  return start3;
  function start3(code2) {
    if (!self2.parser.lazy[self2.now().line] && (self2.interrupt || paragraph2)) {
      effects.enter("setextHeadingLine");
      effects.enter("setextHeadingLineSequence");
      marker = code2;
      return closingSequence(code2);
    }
    return nok(code2);
  }
  function closingSequence(code2) {
    if (code2 === marker) {
      effects.consume(code2);
      return closingSequence;
    }
    effects.exit("setextHeadingLineSequence");
    return factorySpace(effects, closingSequenceEnd, "lineSuffix")(code2);
  }
  function closingSequenceEnd(code2) {
    if (code2 === null || markdownLineEnding(code2)) {
      effects.exit("setextHeadingLine");
      return ok2(code2);
    }
    return nok(code2);
  }
}

// node_modules/micromark-extension-mdxjs-esm/lib/syntax.js
var nextBlankConstruct2 = {
  tokenize: tokenizeNextBlank2,
  partial: true
};
var allowedAcornTypes = /* @__PURE__ */ new Set([
  "ExportAllDeclaration",
  "ExportDefaultDeclaration",
  "ExportNamedDeclaration",
  "ImportDeclaration"
]);
function mdxjsEsm(options) {
  const exportImportConstruct = {
    tokenize: tokenizeExportImport,
    concrete: true
  };
  if (!options || !options.acorn || !options.acorn.parse) {
    throw new Error("Expected an `acorn` instance passed in as `options.acorn`");
  }
  const acorn = options.acorn;
  const acornOptions = Object.assign(
    {
      ecmaVersion: 2020,
      sourceType: "module"
    },
    options.acornOptions
  );
  return {
    flow: {
      [101]: exportImportConstruct,
      [105]: exportImportConstruct
    }
  };
  function tokenizeExportImport(effects, ok2, nok) {
    const self2 = this;
    const definedModuleSpecifiers = (
      // @ts-expect-error: hush
      self2.parser.definedModuleSpecifiers || // @ts-expect-error: hush
      (self2.parser.definedModuleSpecifiers = [])
    );
    const eventStart = this.events.length + 1;
    let index2 = 0;
    let buffer3;
    return self2.interrupt ? nok : start3;
    function start3(code2) {
      if (self2.now().column > 1)
        return nok(code2);
      buffer3 = code2 === 101 ? "export" : "import";
      effects.enter("mdxjsEsm");
      effects.enter("mdxjsEsmData");
      return keyword(code2);
    }
    function keyword(code2) {
      if (code2 === buffer3.charCodeAt(index2++)) {
        effects.consume(code2);
        return index2 === buffer3.length ? after : keyword;
      }
      return nok(code2);
    }
    function after(code2) {
      if (unicodeWhitespace(code2)) {
        effects.consume(code2);
        return rest;
      }
      return nok(code2);
    }
    function rest(code2) {
      if (code2 === null) {
        return atEndOfData(code2);
      }
      if (markdownLineEnding(code2)) {
        return effects.check(nextBlankConstruct2, atEndOfData, atEol)(code2);
      }
      effects.consume(code2);
      return rest;
    }
    function atEol(code2) {
      effects.exit("mdxjsEsmData");
      return lineStart(code2);
    }
    function lineStart(code2) {
      if (markdownLineEnding(code2)) {
        effects.enter("lineEnding");
        effects.consume(code2);
        effects.exit("lineEnding");
        return lineStart;
      }
      if (code2 === null) {
        return atEnd(code2);
      }
      effects.enter("mdxjsEsmData");
      return rest(code2);
    }
    function atEndOfData(code2) {
      effects.exit("mdxjsEsmData");
      return atEnd(code2);
    }
    function atEnd(code2) {
      let index3 = -1;
      const result = eventsToAcorn(self2.events.slice(eventStart), {
        acorn,
        acornOptions,
        prefix: definedModuleSpecifiers.length > 0 ? "var " + definedModuleSpecifiers.join(",") + "\n" : ""
      });
      if (code2 !== null && result.swallow) {
        return lineStart(code2);
      }
      if (result.error) {
        throw new VFileMessage(
          "Could not parse import/exports with acorn: " + String(result.error),
          {
            // @ts-expect-error: hush
            line: result.error.loc.line,
            // @ts-expect-error: hush
            column: result.error.loc.column + 1,
            // @ts-expect-error: hush
            offset: result.error.pos
          },
          "micromark-extension-mdxjs-esm:acorn"
        );
      }
      if (definedModuleSpecifiers.length > 0) {
        result.estree.body.shift();
      }
      while (++index3 < result.estree.body.length) {
        const node2 = result.estree.body[index3];
        if (!allowedAcornTypes.has(node2.type)) {
          throw new VFileMessage(
            "Unexpected `" + node2.type + "` in code: only import/exports are supported",
            positionFromEstree(node2),
            "micromark-extension-mdxjs-esm:non-esm"
          );
        }
        if (node2.type === "ImportDeclaration" && !self2.interrupt) {
          let index4 = -1;
          while (++index4 < node2.specifiers.length) {
            definedModuleSpecifiers.push(node2.specifiers[index4].local.name);
          }
        }
      }
      Object.assign(
        effects.exit("mdxjsEsm"),
        options.addResult ? {
          estree: result.estree
        } : void 0
      );
      return ok2(code2);
    }
  }
}
function tokenizeNextBlank2(effects, ok2, nok) {
  return start3;
  function start3(code2) {
    effects.exit("mdxjsEsmData");
    effects.enter("lineEndingBlank");
    effects.consume(code2);
    effects.exit("lineEndingBlank");
    return effects.attempt(blankLine, ok2, nok);
  }
}

// node_modules/micromark-extension-mdxjs/index.js
function mdxjs(options) {
  const settings = Object.assign(
    {
      acorn: Parser.extend((0, import_acorn_jsx.default)()),
      acornOptions: { ecmaVersion: 2020, sourceType: "module" },
      addResult: true
    },
    options
  );
  return combineExtensions([
    mdxjsEsm(settings),
    mdxExpression(settings),
    mdxJsx(settings),
    mdxMd
  ]);
}

// node_modules/mdast-util-mdx-expression/lib/index.js
var mdxExpressionFromMarkdown = {
  enter: {
    mdxFlowExpression: enterMdxFlowExpression,
    mdxTextExpression: enterMdxTextExpression
  },
  exit: {
    mdxFlowExpression: exitMdxExpression,
    mdxFlowExpressionChunk: exitMdxExpressionData,
    mdxTextExpression: exitMdxExpression,
    mdxTextExpressionChunk: exitMdxExpressionData
  }
};
var mdxExpressionToMarkdown = {
  handlers: {
    mdxFlowExpression: handleMdxExpression,
    mdxTextExpression: handleMdxExpression
  },
  unsafe: [
    { character: "{", inConstruct: ["phrasing"] },
    { atBreak: true, character: "{" }
  ]
};
function enterMdxFlowExpression(token2) {
  this.enter({ type: "mdxFlowExpression", value: "" }, token2);
  this.buffer();
}
function enterMdxTextExpression(token2) {
  this.enter({ type: "mdxTextExpression", value: "" }, token2);
  this.buffer();
}
function exitMdxExpression(token2) {
  const value2 = this.resume();
  const estree = token2.estree;
  const node2 = (
    /** @type {MdxFlowExpression | MdxTextExpression} */
    this.exit(token2)
  );
  node2.value = value2;
  if (estree) {
    node2.data = { estree };
  }
}
function exitMdxExpressionData(token2) {
  this.config.enter.data.call(this, token2);
  this.config.exit.data.call(this, token2);
}
function handleMdxExpression(node2) {
  const value2 = node2.value || "";
  return "{" + value2 + "}";
}

// node_modules/ccount/index.js
function ccount(value2, character) {
  const source2 = String(value2);
  if (typeof character !== "string") {
    throw new TypeError("Expected character");
  }
  let count = 0;
  let index2 = source2.indexOf(character);
  while (index2 !== -1) {
    count++;
    index2 = source2.indexOf(character, index2 + character.length);
  }
  return count;
}

// node_modules/character-entities-legacy/index.js
var characterEntitiesLegacy = [
  "AElig",
  "AMP",
  "Aacute",
  "Acirc",
  "Agrave",
  "Aring",
  "Atilde",
  "Auml",
  "COPY",
  "Ccedil",
  "ETH",
  "Eacute",
  "Ecirc",
  "Egrave",
  "Euml",
  "GT",
  "Iacute",
  "Icirc",
  "Igrave",
  "Iuml",
  "LT",
  "Ntilde",
  "Oacute",
  "Ocirc",
  "Ograve",
  "Oslash",
  "Otilde",
  "Ouml",
  "QUOT",
  "REG",
  "THORN",
  "Uacute",
  "Ucirc",
  "Ugrave",
  "Uuml",
  "Yacute",
  "aacute",
  "acirc",
  "acute",
  "aelig",
  "agrave",
  "amp",
  "aring",
  "atilde",
  "auml",
  "brvbar",
  "ccedil",
  "cedil",
  "cent",
  "copy",
  "curren",
  "deg",
  "divide",
  "eacute",
  "ecirc",
  "egrave",
  "eth",
  "euml",
  "frac12",
  "frac14",
  "frac34",
  "gt",
  "iacute",
  "icirc",
  "iexcl",
  "igrave",
  "iquest",
  "iuml",
  "laquo",
  "lt",
  "macr",
  "micro",
  "middot",
  "nbsp",
  "not",
  "ntilde",
  "oacute",
  "ocirc",
  "ograve",
  "ordf",
  "ordm",
  "oslash",
  "otilde",
  "ouml",
  "para",
  "plusmn",
  "pound",
  "quot",
  "raquo",
  "reg",
  "sect",
  "shy",
  "sup1",
  "sup2",
  "sup3",
  "szlig",
  "thorn",
  "times",
  "uacute",
  "ucirc",
  "ugrave",
  "uml",
  "uuml",
  "yacute",
  "yen",
  "yuml"
];

// node_modules/character-reference-invalid/index.js
var characterReferenceInvalid = {
  0: "\uFFFD",
  128: "\u20AC",
  130: "\u201A",
  131: "\u0192",
  132: "\u201E",
  133: "\u2026",
  134: "\u2020",
  135: "\u2021",
  136: "\u02C6",
  137: "\u2030",
  138: "\u0160",
  139: "\u2039",
  140: "\u0152",
  142: "\u017D",
  145: "\u2018",
  146: "\u2019",
  147: "\u201C",
  148: "\u201D",
  149: "\u2022",
  150: "\u2013",
  151: "\u2014",
  152: "\u02DC",
  153: "\u2122",
  154: "\u0161",
  155: "\u203A",
  156: "\u0153",
  158: "\u017E",
  159: "\u0178"
};

// node_modules/is-decimal/index.js
function isDecimal(character) {
  const code2 = typeof character === "string" ? character.charCodeAt(0) : character;
  return code2 >= 48 && code2 <= 57;
}

// node_modules/is-hexadecimal/index.js
function isHexadecimal(character) {
  const code2 = typeof character === "string" ? character.charCodeAt(0) : character;
  return code2 >= 97 && code2 <= 102 || code2 >= 65 && code2 <= 70 || code2 >= 48 && code2 <= 57;
}

// node_modules/is-alphabetical/index.js
function isAlphabetical(character) {
  const code2 = typeof character === "string" ? character.charCodeAt(0) : character;
  return code2 >= 97 && code2 <= 122 || code2 >= 65 && code2 <= 90;
}

// node_modules/is-alphanumerical/index.js
function isAlphanumerical(character) {
  return isAlphabetical(character) || isDecimal(character);
}

// node_modules/parse-entities/lib/index.js
var fromCharCode = String.fromCharCode;
var messages = [
  "",
  /* 1: Non terminated (named) */
  "Named character references must be terminated by a semicolon",
  /* 2: Non terminated (numeric) */
  "Numeric character references must be terminated by a semicolon",
  /* 3: Empty (named) */
  "Named character references cannot be empty",
  /* 4: Empty (numeric) */
  "Numeric character references cannot be empty",
  /* 5: Unknown (named) */
  "Named character references must be known",
  /* 6: Disallowed (numeric) */
  "Numeric character references cannot be disallowed",
  /* 7: Prohibited (numeric) */
  "Numeric character references cannot be outside the permissible Unicode range"
];
function parseEntities(value2, options = {}) {
  const additional = typeof options.additional === "string" ? options.additional.charCodeAt(0) : options.additional;
  const result = [];
  let index2 = 0;
  let lines = -1;
  let queue = "";
  let point4;
  let indent;
  if (options.position) {
    if ("start" in options.position || "indent" in options.position) {
      indent = options.position.indent;
      point4 = options.position.start;
    } else {
      point4 = options.position;
    }
  }
  let line2 = (point4 ? point4.line : 0) || 1;
  let column2 = (point4 ? point4.column : 0) || 1;
  let previous2 = now();
  let character;
  index2--;
  while (++index2 <= value2.length) {
    if (character === 10) {
      column2 = (indent ? indent[lines] : 0) || 1;
    }
    character = value2.charCodeAt(index2);
    if (character === 38) {
      const following = value2.charCodeAt(index2 + 1);
      if (following === 9 || following === 10 || following === 12 || following === 32 || following === 38 || following === 60 || Number.isNaN(following) || additional && following === additional) {
        queue += fromCharCode(character);
        column2++;
        continue;
      }
      const start3 = index2 + 1;
      let begin = start3;
      let end = start3;
      let type;
      if (following === 35) {
        end = ++begin;
        const following2 = value2.charCodeAt(end);
        if (following2 === 88 || following2 === 120) {
          type = "hexadecimal";
          end = ++begin;
        } else {
          type = "decimal";
        }
      } else {
        type = "named";
      }
      let characterReferenceCharacters = "";
      let characterReference2 = "";
      let characters = "";
      const test = type === "named" ? isAlphanumerical : type === "decimal" ? isDecimal : isHexadecimal;
      end--;
      while (++end <= value2.length) {
        const following2 = value2.charCodeAt(end);
        if (!test(following2)) {
          break;
        }
        characters += fromCharCode(following2);
        if (type === "named" && characterEntitiesLegacy.includes(characters)) {
          characterReferenceCharacters = characters;
          characterReference2 = decodeNamedCharacterReference(characters);
        }
      }
      let terminated = value2.charCodeAt(end) === 59;
      if (terminated) {
        end++;
        const namedReference = type === "named" ? decodeNamedCharacterReference(characters) : false;
        if (namedReference) {
          characterReferenceCharacters = characters;
          characterReference2 = namedReference;
        }
      }
      let diff = 1 + end - start3;
      let reference = "";
      if (!terminated && options.nonTerminated === false) {
      } else if (!characters) {
        if (type !== "named") {
          warning(4, diff);
        }
      } else if (type === "named") {
        if (terminated && !characterReference2) {
          warning(5, 1);
        } else {
          if (characterReferenceCharacters !== characters) {
            end = begin + characterReferenceCharacters.length;
            diff = 1 + end - begin;
            terminated = false;
          }
          if (!terminated) {
            const reason = characterReferenceCharacters ? 1 : 3;
            if (options.attribute) {
              const following2 = value2.charCodeAt(end);
              if (following2 === 61) {
                warning(reason, diff);
                characterReference2 = "";
              } else if (isAlphanumerical(following2)) {
                characterReference2 = "";
              } else {
                warning(reason, diff);
              }
            } else {
              warning(reason, diff);
            }
          }
        }
        reference = characterReference2;
      } else {
        if (!terminated) {
          warning(2, diff);
        }
        let referenceCode = Number.parseInt(
          characters,
          type === "hexadecimal" ? 16 : 10
        );
        if (prohibited(referenceCode)) {
          warning(7, diff);
          reference = fromCharCode(
            65533
            /* `�` */
          );
        } else if (referenceCode in characterReferenceInvalid) {
          warning(6, diff);
          reference = characterReferenceInvalid[referenceCode];
        } else {
          let output = "";
          if (disallowed(referenceCode)) {
            warning(6, diff);
          }
          if (referenceCode > 65535) {
            referenceCode -= 65536;
            output += fromCharCode(referenceCode >>> (10 & 1023) | 55296);
            referenceCode = 56320 | referenceCode & 1023;
          }
          reference = output + fromCharCode(referenceCode);
        }
      }
      if (reference) {
        flush();
        previous2 = now();
        index2 = end - 1;
        column2 += end - start3 + 1;
        result.push(reference);
        const next = now();
        next.offset++;
        if (options.reference) {
          options.reference.call(
            options.referenceContext,
            reference,
            { start: previous2, end: next },
            value2.slice(start3 - 1, end)
          );
        }
        previous2 = next;
      } else {
        characters = value2.slice(start3 - 1, end);
        queue += characters;
        column2 += characters.length;
        index2 = end - 1;
      }
    } else {
      if (character === 10) {
        line2++;
        lines++;
        column2 = 0;
      }
      if (Number.isNaN(character)) {
        flush();
      } else {
        queue += fromCharCode(character);
        column2++;
      }
    }
  }
  return result.join("");
  function now() {
    return {
      line: line2,
      column: column2,
      offset: index2 + ((point4 ? point4.offset : 0) || 0)
    };
  }
  function warning(code2, offset3) {
    let position3;
    if (options.warning) {
      position3 = now();
      position3.column += offset3;
      position3.offset += offset3;
      options.warning.call(
        options.warningContext,
        messages[code2],
        position3,
        code2
      );
    }
  }
  function flush() {
    if (queue) {
      result.push(queue);
      if (options.text) {
        options.text.call(options.textContext, queue, {
          start: previous2,
          end: now()
        });
      }
      queue = "";
    }
  }
}
function prohibited(code2) {
  return code2 >= 55296 && code2 <= 57343 || code2 > 1114111;
}
function disallowed(code2) {
  return code2 >= 1 && code2 <= 8 || code2 === 11 || code2 >= 13 && code2 <= 31 || code2 >= 127 && code2 <= 159 || code2 >= 64976 && code2 <= 65007 || (code2 & 65535) === 65535 || (code2 & 65535) === 65534;
}

// node_modules/stringify-entities/lib/core.js
function core(value2, options) {
  value2 = value2.replace(
    options.subset ? charactersToExpression(options.subset) : /["&'<>`]/g,
    basic
  );
  if (options.subset || options.escapeOnly) {
    return value2;
  }
  return value2.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, surrogate).replace(
    // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
    /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,
    basic
  );
  function surrogate(pair, index2, all4) {
    return options.format(
      (pair.charCodeAt(0) - 55296) * 1024 + pair.charCodeAt(1) - 56320 + 65536,
      all4.charCodeAt(index2 + 2),
      options
    );
  }
  function basic(character, index2, all4) {
    return options.format(
      character.charCodeAt(0),
      all4.charCodeAt(index2 + 1),
      options
    );
  }
}
function charactersToExpression(subset) {
  const groups = [];
  let index2 = -1;
  while (++index2 < subset.length) {
    groups.push(subset[index2].replace(/[|\\{}()[\]^$+*?.]/g, "\\$&"));
  }
  return new RegExp("(?:" + groups.join("|") + ")", "g");
}

// node_modules/stringify-entities/lib/util/format-basic.js
function formatBasic(code2) {
  return "&#x" + code2.toString(16).toUpperCase() + ";";
}

// node_modules/stringify-entities/lib/index.js
function stringifyEntitiesLight(value2, options) {
  return core(value2, Object.assign({ format: formatBasic }, options));
}

// node_modules/mdast-util-to-markdown/lib/util/container-flow.js
function containerFlow(parent, state, info) {
  const indexStack = state.indexStack;
  const children = parent.children || [];
  const tracker = state.createTracker(info);
  const results = [];
  let index2 = -1;
  indexStack.push(-1);
  while (++index2 < children.length) {
    const child = children[index2];
    indexStack[indexStack.length - 1] = index2;
    results.push(
      tracker.move(
        state.handle(child, parent, state, {
          before: "\n",
          after: "\n",
          ...tracker.current()
        })
      )
    );
    if (child.type !== "list") {
      state.bulletLastUsed = void 0;
    }
    if (index2 < children.length - 1) {
      results.push(
        tracker.move(between(child, children[index2 + 1], parent, state))
      );
    }
  }
  indexStack.pop();
  return results.join("");
}
function between(left, right, parent, state) {
  let index2 = state.join.length;
  while (index2--) {
    const result = state.join[index2](left, right, parent, state);
    if (result === true || result === 1) {
      break;
    }
    if (typeof result === "number") {
      return "\n".repeat(1 + result);
    }
    if (result === false) {
      return "\n\n<!---->\n\n";
    }
  }
  return "\n\n";
}

// node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
function containerPhrasing(parent, state, info) {
  const indexStack = state.indexStack;
  const children = parent.children || [];
  const results = [];
  let index2 = -1;
  let before = info.before;
  indexStack.push(-1);
  let tracker = state.createTracker(info);
  while (++index2 < children.length) {
    const child = children[index2];
    let after;
    indexStack[indexStack.length - 1] = index2;
    if (index2 + 1 < children.length) {
      let handle = state.handle.handlers[children[index2 + 1].type];
      if (handle && handle.peek)
        handle = handle.peek;
      after = handle ? handle(children[index2 + 1], parent, state, {
        before: "",
        after: "",
        ...tracker.current()
      }).charAt(0) : "";
    } else {
      after = info.after;
    }
    if (results.length > 0 && (before === "\r" || before === "\n") && child.type === "html") {
      results[results.length - 1] = results[results.length - 1].replace(
        /(\r?\n|\r)$/,
        " "
      );
      before = " ";
      tracker = state.createTracker(info);
      tracker.move(results.join(""));
    }
    results.push(
      tracker.move(
        state.handle(child, parent, state, {
          ...tracker.current(),
          before,
          after
        })
      )
    );
    before = results[results.length - 1].slice(-1);
  }
  indexStack.pop();
  return results.join("");
}

// node_modules/mdast-util-to-markdown/lib/util/indent-lines.js
var eol = /\r?\n|\r/g;
function indentLines(value2, map) {
  const result = [];
  let start3 = 0;
  let line2 = 0;
  let match;
  while (match = eol.exec(value2)) {
    one3(value2.slice(start3, match.index));
    result.push(match[0]);
    start3 = match.index + match[0].length;
    line2++;
  }
  one3(value2.slice(start3));
  return result.join("");
  function one3(value3) {
    result.push(map(value3, line2, !value3));
  }
}

// node_modules/mdast-util-to-markdown/lib/util/track.js
function track(config) {
  const options = config || {};
  const now = options.now || {};
  let lineShift = options.lineShift || 0;
  let line2 = now.line || 1;
  let column2 = now.column || 1;
  return { move, current: current3, shift };
  function current3() {
    return { now: { line: line2, column: column2 }, lineShift };
  }
  function shift(value2) {
    lineShift += value2;
  }
  function move(input) {
    const value2 = input || "";
    const chunks = value2.split(/\r?\n|\r/g);
    const tail = chunks[chunks.length - 1];
    line2 += chunks.length - 1;
    column2 = chunks.length === 1 ? column2 + tail.length : 1 + tail.length + lineShift;
    return value2;
  }
}

// node_modules/mdast-util-mdx-jsx/lib/index.js
function mdxJsxFromMarkdown() {
  return {
    canContainEols: ["mdxJsxTextElement"],
    enter: {
      mdxJsxFlowTag: enterMdxJsxTag,
      mdxJsxFlowTagClosingMarker: enterMdxJsxTagClosingMarker,
      mdxJsxFlowTagAttribute: enterMdxJsxTagAttribute,
      mdxJsxFlowTagExpressionAttribute: enterMdxJsxTagExpressionAttribute,
      mdxJsxFlowTagAttributeValueLiteral: buffer3,
      mdxJsxFlowTagAttributeValueExpression: buffer3,
      mdxJsxFlowTagSelfClosingMarker: enterMdxJsxTagSelfClosingMarker,
      mdxJsxTextTag: enterMdxJsxTag,
      mdxJsxTextTagClosingMarker: enterMdxJsxTagClosingMarker,
      mdxJsxTextTagAttribute: enterMdxJsxTagAttribute,
      mdxJsxTextTagExpressionAttribute: enterMdxJsxTagExpressionAttribute,
      mdxJsxTextTagAttributeValueLiteral: buffer3,
      mdxJsxTextTagAttributeValueExpression: buffer3,
      mdxJsxTextTagSelfClosingMarker: enterMdxJsxTagSelfClosingMarker
    },
    exit: {
      mdxJsxFlowTagClosingMarker: exitMdxJsxTagClosingMarker,
      mdxJsxFlowTagNamePrimary: exitMdxJsxTagNamePrimary,
      mdxJsxFlowTagNameMember: exitMdxJsxTagNameMember,
      mdxJsxFlowTagNameLocal: exitMdxJsxTagNameLocal,
      mdxJsxFlowTagExpressionAttribute: exitMdxJsxTagExpressionAttribute,
      mdxJsxFlowTagExpressionAttributeValue: data3,
      mdxJsxFlowTagAttributeNamePrimary: exitMdxJsxTagAttributeNamePrimary,
      mdxJsxFlowTagAttributeNameLocal: exitMdxJsxTagAttributeNameLocal,
      mdxJsxFlowTagAttributeValueLiteral: exitMdxJsxTagAttributeValueLiteral,
      mdxJsxFlowTagAttributeValueLiteralValue: data3,
      mdxJsxFlowTagAttributeValueExpression: exitMdxJsxTagAttributeValueExpression,
      mdxJsxFlowTagAttributeValueExpressionValue: data3,
      mdxJsxFlowTagSelfClosingMarker: exitMdxJsxTagSelfClosingMarker,
      mdxJsxFlowTag: exitMdxJsxTag,
      mdxJsxTextTagClosingMarker: exitMdxJsxTagClosingMarker,
      mdxJsxTextTagNamePrimary: exitMdxJsxTagNamePrimary,
      mdxJsxTextTagNameMember: exitMdxJsxTagNameMember,
      mdxJsxTextTagNameLocal: exitMdxJsxTagNameLocal,
      mdxJsxTextTagExpressionAttribute: exitMdxJsxTagExpressionAttribute,
      mdxJsxTextTagExpressionAttributeValue: data3,
      mdxJsxTextTagAttributeNamePrimary: exitMdxJsxTagAttributeNamePrimary,
      mdxJsxTextTagAttributeNameLocal: exitMdxJsxTagAttributeNameLocal,
      mdxJsxTextTagAttributeValueLiteral: exitMdxJsxTagAttributeValueLiteral,
      mdxJsxTextTagAttributeValueLiteralValue: data3,
      mdxJsxTextTagAttributeValueExpression: exitMdxJsxTagAttributeValueExpression,
      mdxJsxTextTagAttributeValueExpressionValue: data3,
      mdxJsxTextTagSelfClosingMarker: exitMdxJsxTagSelfClosingMarker,
      mdxJsxTextTag: exitMdxJsxTag
    }
  };
  function buffer3() {
    this.buffer();
  }
  function data3(token2) {
    this.config.enter.data.call(this, token2);
    this.config.exit.data.call(this, token2);
  }
  function enterMdxJsxTag(token2) {
    const tag = {
      name: void 0,
      attributes: [],
      close: false,
      selfClosing: false,
      start: token2.start,
      end: token2.end
    };
    if (!this.getData("mdxJsxTagStack"))
      this.setData("mdxJsxTagStack", []);
    this.setData("mdxJsxTag", tag);
    this.buffer();
  }
  function enterMdxJsxTagClosingMarker(token2) {
    const stack2 = (
      /** @type {Array<Tag>} */
      this.getData("mdxJsxTagStack")
    );
    if (stack2.length === 0) {
      throw new VFileMessage(
        "Unexpected closing slash `/` in tag, expected an open tag first",
        { start: token2.start, end: token2.end },
        "mdast-util-mdx-jsx:unexpected-closing-slash"
      );
    }
  }
  function enterMdxJsxTagAnyAttribute(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    if (tag.close) {
      throw new VFileMessage(
        "Unexpected attribute in closing tag, expected the end of the tag",
        { start: token2.start, end: token2.end },
        "mdast-util-mdx-jsx:unexpected-attribute"
      );
    }
  }
  function enterMdxJsxTagSelfClosingMarker(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    if (tag.close) {
      throw new VFileMessage(
        "Unexpected self-closing slash `/` in closing tag, expected the end of the tag",
        { start: token2.start, end: token2.end },
        "mdast-util-mdx-jsx:unexpected-self-closing-slash"
      );
    }
  }
  function exitMdxJsxTagClosingMarker() {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    tag.close = true;
  }
  function exitMdxJsxTagNamePrimary(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    tag.name = this.sliceSerialize(token2);
  }
  function exitMdxJsxTagNameMember(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    tag.name += "." + this.sliceSerialize(token2);
  }
  function exitMdxJsxTagNameLocal(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    tag.name += ":" + this.sliceSerialize(token2);
  }
  function enterMdxJsxTagAttribute(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    enterMdxJsxTagAnyAttribute.call(this, token2);
    tag.attributes.push({ type: "mdxJsxAttribute", name: "", value: null });
  }
  function enterMdxJsxTagExpressionAttribute(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    enterMdxJsxTagAnyAttribute.call(this, token2);
    tag.attributes.push({ type: "mdxJsxExpressionAttribute", value: "" });
    this.buffer();
  }
  function exitMdxJsxTagExpressionAttribute(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    const tail = (
      /** @type {MdxJsxExpressionAttribute} */
      tag.attributes[tag.attributes.length - 1]
    );
    const estree = token2.estree;
    tail.value = this.resume();
    if (estree) {
      tail.data = { estree };
    }
  }
  function exitMdxJsxTagAttributeNamePrimary(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    const node2 = (
      /** @type {MdxJsxAttribute} */
      tag.attributes[tag.attributes.length - 1]
    );
    node2.name = this.sliceSerialize(token2);
  }
  function exitMdxJsxTagAttributeNameLocal(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    const node2 = (
      /** @type {MdxJsxAttribute} */
      tag.attributes[tag.attributes.length - 1]
    );
    node2.name += ":" + this.sliceSerialize(token2);
  }
  function exitMdxJsxTagAttributeValueLiteral() {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    tag.attributes[tag.attributes.length - 1].value = parseEntities(
      this.resume(),
      { nonTerminated: false }
    );
  }
  function exitMdxJsxTagAttributeValueExpression(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    const tail = (
      /** @type {MdxJsxAttribute} */
      tag.attributes[tag.attributes.length - 1]
    );
    const node2 = { type: "mdxJsxAttributeValueExpression", value: this.resume() };
    const estree = token2.estree;
    if (estree) {
      node2.data = { estree };
    }
    tail.value = node2;
  }
  function exitMdxJsxTagSelfClosingMarker() {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    tag.selfClosing = true;
  }
  function exitMdxJsxTag(token2) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    const stack2 = (
      /** @type {Array<Tag>} */
      this.getData("mdxJsxTagStack")
    );
    const tail = stack2[stack2.length - 1];
    if (tag.close && tail.name !== tag.name) {
      throw new VFileMessage(
        "Unexpected closing tag `" + serializeAbbreviatedTag(tag) + "`, expected corresponding closing tag for `" + serializeAbbreviatedTag(tail) + "` (" + stringifyPosition(tail) + ")",
        { start: token2.start, end: token2.end },
        "mdast-util-mdx-jsx:end-tag-mismatch"
      );
    }
    this.resume();
    if (tag.close) {
      stack2.pop();
    } else {
      this.enter(
        {
          type: token2.type === "mdxJsxTextTag" ? "mdxJsxTextElement" : "mdxJsxFlowElement",
          name: tag.name || null,
          attributes: tag.attributes,
          children: []
        },
        token2,
        onErrorRightIsTag
      );
    }
    if (tag.selfClosing || tag.close) {
      this.exit(token2, onErrorLeftIsTag);
    } else {
      stack2.push(tag);
    }
  }
  function onErrorRightIsTag(closing, open) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    const place = closing ? " before the end of `" + closing.type + "`" : "";
    const position3 = closing ? { start: closing.start, end: closing.end } : void 0;
    throw new VFileMessage(
      "Expected a closing tag for `" + serializeAbbreviatedTag(tag) + "` (" + stringifyPosition({ start: open.start, end: open.end }) + ")" + place,
      position3,
      "mdast-util-mdx-jsx:end-tag-mismatch"
    );
  }
  function onErrorLeftIsTag(a, b) {
    const tag = (
      /** @type {Tag} */
      this.getData("mdxJsxTag")
    );
    throw new VFileMessage(
      "Expected the closing tag `" + serializeAbbreviatedTag(tag) + "` either after the end of `" + b.type + "` (" + stringifyPosition(b.end) + ") or another opening tag after the start of `" + b.type + "` (" + stringifyPosition(b.start) + ")",
      { start: a.start, end: a.end },
      "mdast-util-mdx-jsx:end-tag-mismatch"
    );
  }
  function serializeAbbreviatedTag(tag) {
    return "<" + (tag.close ? "/" : "") + (tag.name || "") + ">";
  }
}
function mdxJsxToMarkdown(options) {
  const options_ = options || {};
  const quote = options_.quote || '"';
  const quoteSmart = options_.quoteSmart || false;
  const tightSelfClosing = options_.tightSelfClosing || false;
  const printWidth = options_.printWidth || Number.POSITIVE_INFINITY;
  const alternative = quote === '"' ? "'" : '"';
  if (quote !== '"' && quote !== "'") {
    throw new Error(
      "Cannot serialize attribute values with `" + quote + "` for `options.quote`, expected `\"`, or `'`"
    );
  }
  mdxElement.peek = peekElement;
  return {
    handlers: {
      mdxJsxFlowElement: mdxElement,
      mdxJsxTextElement: mdxElement
    },
    unsafe: [
      { character: "<", inConstruct: ["phrasing"] },
      { atBreak: true, character: "<" }
    ],
    // Always generate fenced code (never indented code).
    fences: true,
    // Always generate links with resources (never autolinks).
    resourceLink: true
  };
  function mdxElement(node2, _, context, safeOptions) {
    const tracker = track(safeOptions);
    const selfClosing = node2.name && (!node2.children || node2.children.length === 0);
    const exit2 = context.enter(node2.type);
    let index2 = -1;
    const serializedAttributes = [];
    let value2 = tracker.move("<" + (node2.name || ""));
    if (node2.attributes && node2.attributes.length > 0) {
      if (!node2.name) {
        throw new Error("Cannot serialize fragment w/ attributes");
      }
      while (++index2 < node2.attributes.length) {
        const attribute = node2.attributes[index2];
        let result;
        if (attribute.type === "mdxJsxExpressionAttribute") {
          result = "{" + (attribute.value || "") + "}";
        } else {
          if (!attribute.name) {
            throw new Error("Cannot serialize attribute w/o name");
          }
          const value3 = attribute.value;
          const left = attribute.name;
          let right = "";
          if (value3 === void 0 || value3 === null) {
          } else if (typeof value3 === "object") {
            right = "{" + (value3.value || "") + "}";
          } else {
            const appliedQuote = quoteSmart && ccount(value3, quote) > ccount(value3, alternative) ? alternative : quote;
            right = appliedQuote + stringifyEntitiesLight(value3, { subset: [appliedQuote] }) + appliedQuote;
          }
          result = left + (right ? "=" : "") + right;
        }
        serializedAttributes.push(result);
      }
    }
    let attributesOnTheirOwnLine = false;
    const attributesOnOneLine = serializedAttributes.join(" ");
    if (
      // Block:
      node2.type === "mdxJsxFlowElement" && // Including a line ending (expressions).
      (/\r?\n|\r/.test(attributesOnOneLine) || // Current position (including `<tag`).
      tracker.current().now.column + // -1 because columns, +1 for ` ` before attributes.
      // Attributes joined by spaces.
      attributesOnOneLine.length + // ` />`.
      (selfClosing ? tightSelfClosing ? 2 : 3 : 1) > printWidth)
    ) {
      attributesOnTheirOwnLine = true;
    }
    if (attributesOnTheirOwnLine) {
      value2 += tracker.move(
        "\n" + indentLines(serializedAttributes.join("\n"), map)
      );
    } else if (attributesOnOneLine) {
      value2 += tracker.move(" " + attributesOnOneLine);
    }
    if (attributesOnTheirOwnLine) {
      value2 += tracker.move("\n");
    }
    if (selfClosing) {
      value2 += tracker.move(
        (tightSelfClosing || attributesOnTheirOwnLine ? "" : " ") + "/"
      );
    }
    value2 += tracker.move(">");
    if (node2.children && node2.children.length > 0) {
      if (node2.type === "mdxJsxFlowElement") {
        tracker.shift(2);
        value2 += tracker.move("\n");
        value2 += tracker.move(
          indentLines(containerFlow(node2, context, tracker.current()), map)
        );
        value2 += tracker.move("\n");
      } else {
        value2 += tracker.move(
          containerPhrasing(node2, context, {
            ...tracker.current(),
            before: "<",
            after: ">"
          })
        );
      }
    }
    if (!selfClosing) {
      value2 += tracker.move("</" + (node2.name || "") + ">");
    }
    exit2();
    return value2;
  }
  function map(line2, _, blank) {
    return (blank ? "" : "  ") + line2;
  }
  function peekElement() {
    return "<";
  }
}

// node_modules/mdast-util-mdxjs-esm/lib/index.js
var mdxjsEsmFromMarkdown = {
  enter: { mdxjsEsm: enterMdxjsEsm },
  exit: { mdxjsEsm: exitMdxjsEsm, mdxjsEsmData: exitMdxjsEsmData }
};
var mdxjsEsmToMarkdown = { handlers: { mdxjsEsm: handleMdxjsEsm } };
function enterMdxjsEsm(token2) {
  this.enter({ type: "mdxjsEsm", value: "" }, token2);
  this.buffer();
}
function exitMdxjsEsm(token2) {
  const value2 = this.resume();
  const node2 = (
    /** @type {MdxjsEsm} */
    this.exit(token2)
  );
  const estree = token2.estree;
  node2.value = value2;
  if (estree) {
    node2.data = { estree };
  }
}
function exitMdxjsEsmData(token2) {
  this.config.enter.data.call(this, token2);
  this.config.exit.data.call(this, token2);
}
function handleMdxjsEsm(node2) {
  return node2.value || "";
}

// node_modules/mdast-util-mdx/index.js
function mdxFromMarkdown() {
  return [mdxExpressionFromMarkdown, mdxJsxFromMarkdown(), mdxjsEsmFromMarkdown];
}
function mdxToMarkdown(options) {
  return {
    extensions: [
      mdxExpressionToMarkdown,
      mdxJsxToMarkdown(options),
      mdxjsEsmToMarkdown
    ]
  };
}

// node_modules/remark-mdx/index.js
function remarkMdx(options) {
  const data3 = this.data();
  add("micromarkExtensions", mdxjs(options));
  add("fromMarkdownExtensions", mdxFromMarkdown());
  add("toMarkdownExtensions", mdxToMarkdown(options));
  function add(field, value2) {
    const list3 = (
      /** @type {Array<unknown>} */
      // Other extensions
      /* c8 ignore next 2 */
      data3[field] ? data3[field] : data3[field] = []
    );
    list3.push(value2);
  }
}

// node_modules/mdast-util-to-string/lib/index.js
var emptyOptions = {};
function toString3(value2, options) {
  const settings = options || emptyOptions;
  const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
  const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
  return one(value2, includeImageAlt, includeHtml);
}
function one(value2, includeImageAlt, includeHtml) {
  if (node(value2)) {
    if ("value" in value2) {
      return value2.type === "html" && !includeHtml ? "" : value2.value;
    }
    if (includeImageAlt && "alt" in value2 && value2.alt) {
      return value2.alt;
    }
    if ("children" in value2) {
      return all(value2.children, includeImageAlt, includeHtml);
    }
  }
  if (Array.isArray(value2)) {
    return all(value2, includeImageAlt, includeHtml);
  }
  return "";
}
function all(values, includeImageAlt, includeHtml) {
  const result = [];
  let index2 = -1;
  while (++index2 < values.length) {
    result[index2] = one(values[index2], includeImageAlt, includeHtml);
  }
  return result.join("");
}
function node(value2) {
  return Boolean(value2 && typeof value2 === "object");
}

// node_modules/micromark/lib/initialize/content.js
var content2 = {
  tokenize: initializeContent
};
function initializeContent(effects) {
  const contentStart = effects.attempt(
    this.parser.constructs.contentInitial,
    afterContentStartConstruct,
    paragraphInitial
  );
  let previous2;
  return contentStart;
  function afterContentStartConstruct(code2) {
    if (code2 === null) {
      effects.consume(code2);
      return;
    }
    effects.enter("lineEnding");
    effects.consume(code2);
    effects.exit("lineEnding");
    return factorySpace(effects, contentStart, "linePrefix");
  }
  function paragraphInitial(code2) {
    effects.enter("paragraph");
    return lineStart(code2);
  }
  function lineStart(code2) {
    const token2 = effects.enter("chunkText", {
      contentType: "text",
      previous: previous2
    });
    if (previous2) {
      previous2.next = token2;
    }
    previous2 = token2;
    return data3(code2);
  }
  function data3(code2) {
    if (code2 === null) {
      effects.exit("chunkText");
      effects.exit("paragraph");
      effects.consume(code2);
      return;
    }
    if (markdownLineEnding(code2)) {
      effects.consume(code2);
      effects.exit("chunkText");
      return lineStart;
    }
    effects.consume(code2);
    return data3;
  }
}

// node_modules/micromark/lib/initialize/document.js
var document2 = {
  tokenize: initializeDocument
};
var containerConstruct = {
  tokenize: tokenizeContainer
};
function initializeDocument(effects) {
  const self2 = this;
  const stack2 = [];
  let continued = 0;
  let childFlow;
  let childToken;
  let lineStartOffset;
  return start3;
  function start3(code2) {
    if (continued < stack2.length) {
      const item = stack2[continued];
      self2.containerState = item[1];
      return effects.attempt(
        item[0].continuation,
        documentContinue,
        checkNewContainers
      )(code2);
    }
    return checkNewContainers(code2);
  }
  function documentContinue(code2) {
    continued++;
    if (self2.containerState._closeFlow) {
      self2.containerState._closeFlow = void 0;
      if (childFlow) {
        closeFlow();
      }
      const indexBeforeExits = self2.events.length;
      let indexBeforeFlow = indexBeforeExits;
      let point4;
      while (indexBeforeFlow--) {
        if (self2.events[indexBeforeFlow][0] === "exit" && self2.events[indexBeforeFlow][1].type === "chunkFlow") {
          point4 = self2.events[indexBeforeFlow][1].end;
          break;
        }
      }
      exitContainers(continued);
      let index2 = indexBeforeExits;
      while (index2 < self2.events.length) {
        self2.events[index2][1].end = Object.assign({}, point4);
        index2++;
      }
      splice(
        self2.events,
        indexBeforeFlow + 1,
        0,
        self2.events.slice(indexBeforeExits)
      );
      self2.events.length = index2;
      return checkNewContainers(code2);
    }
    return start3(code2);
  }
  function checkNewContainers(code2) {
    if (continued === stack2.length) {
      if (!childFlow) {
        return documentContinued(code2);
      }
      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
        return flowStart(code2);
      }
      self2.interrupt = Boolean(
        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack
      );
    }
    self2.containerState = {};
    return effects.check(
      containerConstruct,
      thereIsANewContainer,
      thereIsNoNewContainer
    )(code2);
  }
  function thereIsANewContainer(code2) {
    if (childFlow)
      closeFlow();
    exitContainers(continued);
    return documentContinued(code2);
  }
  function thereIsNoNewContainer(code2) {
    self2.parser.lazy[self2.now().line] = continued !== stack2.length;
    lineStartOffset = self2.now().offset;
    return flowStart(code2);
  }
  function documentContinued(code2) {
    self2.containerState = {};
    return effects.attempt(
      containerConstruct,
      containerContinue,
      flowStart
    )(code2);
  }
  function containerContinue(code2) {
    continued++;
    stack2.push([self2.currentConstruct, self2.containerState]);
    return documentContinued(code2);
  }
  function flowStart(code2) {
    if (code2 === null) {
      if (childFlow)
        closeFlow();
      exitContainers(0);
      effects.consume(code2);
      return;
    }
    childFlow = childFlow || self2.parser.flow(self2.now());
    effects.enter("chunkFlow", {
      contentType: "flow",
      previous: childToken,
      _tokenizer: childFlow
    });
    return flowContinue(code2);
  }
  function flowContinue(code2) {
    if (code2 === null) {
      writeToChild(effects.exit("chunkFlow"), true);
      exitContainers(0);
      effects.consume(code2);
      return;
    }
    if (markdownLineEnding(code2)) {
      effects.consume(code2);
      writeToChild(effects.exit("chunkFlow"));
      continued = 0;
      self2.interrupt = void 0;
      return start3;
    }
    effects.consume(code2);
    return flowContinue;
  }
  function writeToChild(token2, eof) {
    const stream = self2.sliceStream(token2);
    if (eof)
      stream.push(null);
    token2.previous = childToken;
    if (childToken)
      childToken.next = token2;
    childToken = token2;
    childFlow.defineSkip(token2.start);
    childFlow.write(stream);
    if (self2.parser.lazy[token2.start.line]) {
      let index2 = childFlow.events.length;
      while (index2--) {
        if (
          // The token starts before the line ending…
          childFlow.events[index2][1].start.offset < lineStartOffset && // …and either is not ended yet…
          (!childFlow.events[index2][1].end || // …or ends after it.
          childFlow.events[index2][1].end.offset > lineStartOffset)
        ) {
          return;
        }
      }
      const indexBeforeExits = self2.events.length;
      let indexBeforeFlow = indexBeforeExits;
      let seen;
      let point4;
      while (indexBeforeFlow--) {
        if (self2.events[indexBeforeFlow][0] === "exit" && self2.events[indexBeforeFlow][1].type === "chunkFlow") {
          if (seen) {
            point4 = self2.events[indexBeforeFlow][1].end;
            break;
          }
          seen = true;
        }
      }
      exitContainers(continued);
      index2 = indexBeforeExits;
      while (index2 < self2.events.length) {
        self2.events[index2][1].end = Object.assign({}, point4);
        index2++;
      }
      splice(
        self2.events,
        indexBeforeFlow + 1,
        0,
        self2.events.slice(indexBeforeExits)
      );
      self2.events.length = index2;
    }
  }
  function exitContainers(size) {
    let index2 = stack2.length;
    while (index2-- > size) {
      const entry = stack2[index2];
      self2.containerState = entry[1];
      entry[0].exit.call(self2, effects);
    }
    stack2.length = size;
  }
  function closeFlow() {
    childFlow.write([null]);
    childToken = void 0;
    childFlow = void 0;
    self2.containerState._closeFlow = void 0;
  }
}
function tokenizeContainer(effects, ok2, nok) {
  return factorySpace(
    effects,
    effects.attempt(this.parser.constructs.document, ok2, nok),
    "linePrefix",
    this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4
  );
}

// node_modules/micromark/lib/initialize/flow.js
var flow = {
  tokenize: initializeFlow
};
function initializeFlow(effects) {
  const self2 = this;
  const initial = effects.attempt(
    // Try to parse a blank line.
    blankLine,
    atBlankEnding,
    // Try to parse initial flow (essentially, only code).
    effects.attempt(
      this.parser.constructs.flowInitial,
      afterConstruct,
      factorySpace(
        effects,
        effects.attempt(
          this.parser.constructs.flow,
          afterConstruct,
          effects.attempt(content, afterConstruct)
        ),
        "linePrefix"
      )
    )
  );
  return initial;
  function atBlankEnding(code2) {
    if (code2 === null) {
      effects.consume(code2);
      return;
    }
    effects.enter("lineEndingBlank");
    effects.consume(code2);
    effects.exit("lineEndingBlank");
    self2.currentConstruct = void 0;
    return initial;
  }
  function afterConstruct(code2) {
    if (code2 === null) {
      effects.consume(code2);
      return;
    }
    effects.enter("lineEnding");
    effects.consume(code2);
    effects.exit("lineEnding");
    self2.currentConstruct = void 0;
    return initial;
  }
}

// node_modules/micromark/lib/initialize/text.js
var resolver = {
  resolveAll: createResolver()
};
var string = initializeFactory("string");
var text = initializeFactory("text");
function initializeFactory(field) {
  return {
    tokenize: initializeText,
    resolveAll: createResolver(
      field === "text" ? resolveAllLineSuffixes : void 0
    )
  };
  function initializeText(effects) {
    const self2 = this;
    const constructs2 = this.parser.constructs[field];
    const text5 = effects.attempt(constructs2, start3, notText);
    return start3;
    function start3(code2) {
      return atBreak(code2) ? text5(code2) : notText(code2);
    }
    function notText(code2) {
      if (code2 === null) {
        effects.consume(code2);
        return;
      }
      effects.enter("data");
      effects.consume(code2);
      return data3;
    }
    function data3(code2) {
      if (atBreak(code2)) {
        effects.exit("data");
        return text5(code2);
      }
      effects.consume(code2);
      return data3;
    }
    function atBreak(code2) {
      if (code2 === null) {
        return true;
      }
      const list3 = constructs2[code2];
      let index2 = -1;
      if (list3) {
        while (++index2 < list3.length) {
          const item = list3[index2];
          if (!item.previous || item.previous.call(self2, self2.previous)) {
            return true;
          }
        }
      }
      return false;
    }
  }
}
function createResolver(extraResolver) {
  return resolveAllText;
  function resolveAllText(events, context) {
    let index2 = -1;
    let enter;
    while (++index2 <= events.length) {
      if (enter === void 0) {
        if (events[index2] && events[index2][1].type === "data") {
          enter = index2;
          index2++;
        }
      } else if (!events[index2] || events[index2][1].type !== "data") {
        if (index2 !== enter + 2) {
          events[enter][1].end = events[index2 - 1][1].end;
          events.splice(enter + 2, index2 - enter - 2);
          index2 = enter + 2;
        }
        enter = void 0;
      }
    }
    return extraResolver ? extraResolver(events, context) : events;
  }
}
function resolveAllLineSuffixes(events, context) {
  let eventIndex = 0;
  while (++eventIndex <= events.length) {
    if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
      const data3 = events[eventIndex - 1][1];
      const chunks = context.sliceStream(data3);
      let index2 = chunks.length;
      let bufferIndex = -1;
      let size = 0;
      let tabs;
      while (index2--) {
        const chunk = chunks[index2];
        if (typeof chunk === "string") {
          bufferIndex = chunk.length;
          while (chunk.charCodeAt(bufferIndex - 1) === 32) {
            size++;
            bufferIndex--;
          }
          if (bufferIndex)
            break;
          bufferIndex = -1;
        } else if (chunk === -2) {
          tabs = true;
          size++;
        } else if (chunk === -1) {
        } else {
          index2++;
          break;
        }
      }
      if (size) {
        const token2 = {
          type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing",
          start: {
            line: data3.end.line,
            column: data3.end.column - size,
            offset: data3.end.offset - size,
            _index: data3.start._index + index2,
            _bufferIndex: index2 ? bufferIndex : data3.start._bufferIndex + bufferIndex
          },
          end: Object.assign({}, data3.end)
        };
        data3.end = Object.assign({}, token2.start);
        if (data3.start.offset === data3.end.offset) {
          Object.assign(data3, token2);
        } else {
          events.splice(
            eventIndex,
            0,
            ["enter", token2, context],
            ["exit", token2, context]
          );
          eventIndex += 2;
        }
      }
      eventIndex++;
    }
  }
  return events;
}

// node_modules/micromark/lib/create-tokenizer.js
function createTokenizer(parser, initialize, from) {
  let point4 = Object.assign(
    from ? Object.assign({}, from) : {
      line: 1,
      column: 1,
      offset: 0
    },
    {
      _index: 0,
      _bufferIndex: -1
    }
  );
  const columnStart = {};
  const resolveAllConstructs = [];
  let chunks = [];
  let stack2 = [];
  let consumed = true;
  const effects = {
    consume,
    enter,
    exit: exit2,
    attempt: constructFactory(onsuccessfulconstruct),
    check: constructFactory(onsuccessfulcheck),
    interrupt: constructFactory(onsuccessfulcheck, {
      interrupt: true
    })
  };
  const context = {
    previous: null,
    code: null,
    containerState: {},
    events: [],
    parser,
    sliceStream,
    sliceSerialize,
    now,
    defineSkip,
    write
  };
  let state = initialize.tokenize.call(context, effects);
  let expectedCode;
  if (initialize.resolveAll) {
    resolveAllConstructs.push(initialize);
  }
  return context;
  function write(slice2) {
    chunks = push(chunks, slice2);
    main();
    if (chunks[chunks.length - 1] !== null) {
      return [];
    }
    addResult(initialize, 0);
    context.events = resolveAll(resolveAllConstructs, context.events, context);
    return context.events;
  }
  function sliceSerialize(token2, expandTabs) {
    return serializeChunks(sliceStream(token2), expandTabs);
  }
  function sliceStream(token2) {
    return sliceChunks(chunks, token2);
  }
  function now() {
    return Object.assign({}, point4);
  }
  function defineSkip(value2) {
    columnStart[value2.line] = value2.column;
    accountForPotentialSkip();
  }
  function main() {
    let chunkIndex;
    while (point4._index < chunks.length) {
      const chunk = chunks[point4._index];
      if (typeof chunk === "string") {
        chunkIndex = point4._index;
        if (point4._bufferIndex < 0) {
          point4._bufferIndex = 0;
        }
        while (point4._index === chunkIndex && point4._bufferIndex < chunk.length) {
          go(chunk.charCodeAt(point4._bufferIndex));
        }
      } else {
        go(chunk);
      }
    }
  }
  function go(code2) {
    consumed = void 0;
    expectedCode = code2;
    state = state(code2);
  }
  function consume(code2) {
    if (markdownLineEnding(code2)) {
      point4.line++;
      point4.column = 1;
      point4.offset += code2 === -3 ? 2 : 1;
      accountForPotentialSkip();
    } else if (code2 !== -1) {
      point4.column++;
      point4.offset++;
    }
    if (point4._bufferIndex < 0) {
      point4._index++;
    } else {
      point4._bufferIndex++;
      if (point4._bufferIndex === chunks[point4._index].length) {
        point4._bufferIndex = -1;
        point4._index++;
      }
    }
    context.previous = code2;
    consumed = true;
  }
  function enter(type, fields) {
    const token2 = fields || {};
    token2.type = type;
    token2.start = now();
    context.events.push(["enter", token2, context]);
    stack2.push(token2);
    return token2;
  }
  function exit2(type) {
    const token2 = stack2.pop();
    token2.end = now();
    context.events.push(["exit", token2, context]);
    return token2;
  }
  function onsuccessfulconstruct(construct, info) {
    addResult(construct, info.from);
  }
  function onsuccessfulcheck(_, info) {
    info.restore();
  }
  function constructFactory(onreturn, fields) {
    return hook;
    function hook(constructs2, returnState, bogusState) {
      let listOfConstructs;
      let constructIndex;
      let currentConstruct;
      let info;
      return Array.isArray(constructs2) ? (
        /* c8 ignore next 1 */
        handleListOfConstructs(constructs2)
      ) : "tokenize" in constructs2 ? handleListOfConstructs([constructs2]) : handleMapOfConstructs(constructs2);
      function handleMapOfConstructs(map) {
        return start3;
        function start3(code2) {
          const def = code2 !== null && map[code2];
          const all4 = code2 !== null && map.null;
          const list3 = [
            // To do: add more extension tests.
            /* c8 ignore next 2 */
            ...Array.isArray(def) ? def : def ? [def] : [],
            ...Array.isArray(all4) ? all4 : all4 ? [all4] : []
          ];
          return handleListOfConstructs(list3)(code2);
        }
      }
      function handleListOfConstructs(list3) {
        listOfConstructs = list3;
        constructIndex = 0;
        if (list3.length === 0) {
          return bogusState;
        }
        return handleConstruct(list3[constructIndex]);
      }
      function handleConstruct(construct) {
        return start3;
        function start3(code2) {
          info = store();
          currentConstruct = construct;
          if (!construct.partial) {
            context.currentConstruct = construct;
          }
          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {
            return nok(code2);
          }
          return construct.tokenize.call(
            // If we do have fields, create an object w/ `context` as its
            // prototype.
            // This allows a “live binding”, which is needed for `interrupt`.
            fields ? Object.assign(Object.create(context), fields) : context,
            effects,
            ok2,
            nok
          )(code2);
        }
      }
      function ok2(code2) {
        consumed = true;
        onreturn(currentConstruct, info);
        return returnState;
      }
      function nok(code2) {
        consumed = true;
        info.restore();
        if (++constructIndex < listOfConstructs.length) {
          return handleConstruct(listOfConstructs[constructIndex]);
        }
        return bogusState;
      }
    }
  }
  function addResult(construct, from2) {
    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
      resolveAllConstructs.push(construct);
    }
    if (construct.resolve) {
      splice(
        context.events,
        from2,
        context.events.length - from2,
        construct.resolve(context.events.slice(from2), context)
      );
    }
    if (construct.resolveTo) {
      context.events = construct.resolveTo(context.events, context);
    }
  }
  function store() {
    const startPoint = now();
    const startPrevious = context.previous;
    const startCurrentConstruct = context.currentConstruct;
    const startEventsIndex = context.events.length;
    const startStack = Array.from(stack2);
    return {
      restore,
      from: startEventsIndex
    };
    function restore() {
      point4 = startPoint;
      context.previous = startPrevious;
      context.currentConstruct = startCurrentConstruct;
      context.events.length = startEventsIndex;
      stack2 = startStack;
      accountForPotentialSkip();
    }
  }
  function accountForPotentialSkip() {
    if (point4.line in columnStart && point4.column < 2) {
      point4.column = columnStart[point4.line];
      point4.offset += columnStart[point4.line] - 1;
    }
  }
}
function sliceChunks(chunks, token2) {
  const startIndex = token2.start._index;
  const startBufferIndex = token2.start._bufferIndex;
  const endIndex = token2.end._index;
  const endBufferIndex = token2.end._bufferIndex;
  let view;
  if (startIndex === endIndex) {
    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
  } else {
    view = chunks.slice(startIndex, endIndex);
    if (startBufferIndex > -1) {
      view[0] = view[0].slice(startBufferIndex);
    }
    if (endBufferIndex > 0) {
      view.push(chunks[endIndex].slice(0, endBufferIndex));
    }
  }
  return view;
}
function serializeChunks(chunks, expandTabs) {
  let index2 = -1;
  const result = [];
  let atTab;
  while (++index2 < chunks.length) {
    const chunk = chunks[index2];
    let value2;
    if (typeof chunk === "string") {
      value2 = chunk;
    } else
      switch (chunk) {
        case -5: {
          value2 = "\r";
          break;
        }
        case -4: {
          value2 = "\n";
          break;
        }
        case -3: {
          value2 = "\r\n";
          break;
        }
        case -2: {
          value2 = expandTabs ? " " : "	";
          break;
        }
        case -1: {
          if (!expandTabs && atTab)
            continue;
          value2 = " ";
          break;
        }
        default: {
          value2 = String.fromCharCode(chunk);
        }
      }
    atTab = chunk === -2;
    result.push(value2);
  }
  return result.join("");
}

// node_modules/micromark/lib/constructs.js
var constructs_exports = {};
__export(constructs_exports, {
  attentionMarkers: () => attentionMarkers,
  contentInitial: () => contentInitial,
  disable: () => disable,
  document: () => document3,
  flow: () => flow2,
  flowInitial: () => flowInitial,
  insideSpan: () => insideSpan,
  string: () => string2,
  text: () => text2
});
var document3 = {
  [42]: list,
  [43]: list,
  [45]: list,
  [48]: list,
  [49]: list,
  [50]: list,
  [51]: list,
  [52]: list,
  [53]: list,
  [54]: list,
  [55]: list,
  [56]: list,
  [57]: list,
  [62]: blockQuote
};
var contentInitial = {
  [91]: definition
};
var flowInitial = {
  [-2]: codeIndented,
  [-1]: codeIndented,
  [32]: codeIndented
};
var flow2 = {
  [35]: headingAtx,
  [42]: thematicBreak,
  [45]: [setextUnderline, thematicBreak],
  [60]: htmlFlow,
  [61]: setextUnderline,
  [95]: thematicBreak,
  [96]: codeFenced,
  [126]: codeFenced
};
var string2 = {
  [38]: characterReference,
  [92]: characterEscape
};
var text2 = {
  [-5]: lineEnding,
  [-4]: lineEnding,
  [-3]: lineEnding,
  [33]: labelStartImage,
  [38]: characterReference,
  [42]: attention,
  [60]: [autolink, htmlText],
  [91]: labelStartLink,
  [92]: [hardBreakEscape, characterEscape],
  [93]: labelEnd,
  [95]: attention,
  [96]: codeText
};
var insideSpan = {
  null: [attention, resolver]
};
var attentionMarkers = {
  null: [42, 95]
};
var disable = {
  null: []
};

// node_modules/micromark/lib/parse.js
function parse6(options = {}) {
  const constructs2 = combineExtensions(
    // @ts-expect-error Same as above.
    [constructs_exports].concat(options.extensions || [])
  );
  const parser = {
    defined: [],
    lazy: {},
    constructs: constructs2,
    content: create4(content2),
    document: create4(document2),
    flow: create4(flow),
    string: create4(string),
    text: create4(text)
  };
  return parser;
  function create4(initial) {
    return creator;
    function creator(from) {
      return createTokenizer(parser, initial, from);
    }
  }
}

// node_modules/micromark/lib/preprocess.js
var search = /[\0\t\n\r]/g;
function preprocess() {
  let column2 = 1;
  let buffer3 = "";
  let start3 = true;
  let atCarriageReturn;
  return preprocessor;
  function preprocessor(value2, encoding, end) {
    const chunks = [];
    let match;
    let next;
    let startPosition;
    let endPosition;
    let code2;
    value2 = buffer3 + value2.toString(encoding);
    startPosition = 0;
    buffer3 = "";
    if (start3) {
      if (value2.charCodeAt(0) === 65279) {
        startPosition++;
      }
      start3 = void 0;
    }
    while (startPosition < value2.length) {
      search.lastIndex = startPosition;
      match = search.exec(value2);
      endPosition = match && match.index !== void 0 ? match.index : value2.length;
      code2 = value2.charCodeAt(endPosition);
      if (!match) {
        buffer3 = value2.slice(startPosition);
        break;
      }
      if (code2 === 10 && startPosition === endPosition && atCarriageReturn) {
        chunks.push(-3);
        atCarriageReturn = void 0;
      } else {
        if (atCarriageReturn) {
          chunks.push(-5);
          atCarriageReturn = void 0;
        }
        if (startPosition < endPosition) {
          chunks.push(value2.slice(startPosition, endPosition));
          column2 += endPosition - startPosition;
        }
        switch (code2) {
          case 0: {
            chunks.push(65533);
            column2++;
            break;
          }
          case 9: {
            next = Math.ceil(column2 / 4) * 4;
            chunks.push(-2);
            while (column2++ < next)
              chunks.push(-1);
            break;
          }
          case 10: {
            chunks.push(-4);
            column2 = 1;
            break;
          }
          default: {
            atCarriageReturn = true;
            column2 = 1;
          }
        }
      }
      startPosition = endPosition + 1;
    }
    if (end) {
      if (atCarriageReturn)
        chunks.push(-5);
      if (buffer3)
        chunks.push(buffer3);
      chunks.push(null);
    }
    return chunks;
  }
}

// node_modules/micromark/lib/postprocess.js
function postprocess(events) {
  while (!subtokenize(events)) {
  }
  return events;
}

// node_modules/micromark-util-decode-numeric-character-reference/index.js
function decodeNumericCharacterReference(value2, base2) {
  const code2 = Number.parseInt(value2, base2);
  if (
    // C0 except for HT, LF, FF, CR, space
    code2 < 9 || code2 === 11 || code2 > 13 && code2 < 32 || // Control character (DEL) of the basic block and C1 controls.
    code2 > 126 && code2 < 160 || // Lone high surrogates and low surrogates.
    code2 > 55295 && code2 < 57344 || // Noncharacters.
    code2 > 64975 && code2 < 65008 || (code2 & 65535) === 65535 || (code2 & 65535) === 65534 || // Out of range
    code2 > 1114111
  ) {
    return "\uFFFD";
  }
  return String.fromCharCode(code2);
}

// node_modules/micromark-util-decode-string/index.js
var characterEscapeOrReference = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
function decodeString(value2) {
  return value2.replace(characterEscapeOrReference, decode);
}
function decode($0, $1, $2) {
  if ($1) {
    return $1;
  }
  const head = $2.charCodeAt(0);
  if (head === 35) {
    const head2 = $2.charCodeAt(1);
    const hex = head2 === 120 || head2 === 88;
    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);
  }
  return decodeNamedCharacterReference($2) || $0;
}

// node_modules/mdast-util-from-markdown/lib/index.js
var own4 = {}.hasOwnProperty;
var fromMarkdown = (
  /**
   * @type {(
   *   ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) &
   *   ((value: Value, options?: Options | null | undefined) => Root)
   * )}
   */
  /**
   * @param {Value} value
   * @param {Encoding | Options | null | undefined} [encoding]
   * @param {Options | null | undefined} [options]
   * @returns {Root}
   */
  function(value2, encoding, options) {
    if (typeof encoding !== "string") {
      options = encoding;
      encoding = void 0;
    }
    return compiler(options)(
      postprocess(
        // @ts-expect-error: micromark types need to accept `null`.
        parse6(options).document().write(preprocess()(value2, encoding, true))
      )
    );
  }
);
function compiler(options) {
  const config = {
    transforms: [],
    canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
    enter: {
      autolink: opener(link2),
      autolinkProtocol: onenterdata,
      autolinkEmail: onenterdata,
      atxHeading: opener(heading2),
      blockQuote: opener(blockQuote2),
      characterEscape: onenterdata,
      characterReference: onenterdata,
      codeFenced: opener(codeFlow),
      codeFencedFenceInfo: buffer3,
      codeFencedFenceMeta: buffer3,
      codeIndented: opener(codeFlow, buffer3),
      codeText: opener(codeText2, buffer3),
      codeTextData: onenterdata,
      data: onenterdata,
      codeFlowValue: onenterdata,
      definition: opener(definition2),
      definitionDestinationString: buffer3,
      definitionLabelString: buffer3,
      definitionTitleString: buffer3,
      emphasis: opener(emphasis2),
      hardBreakEscape: opener(hardBreak2),
      hardBreakTrailing: opener(hardBreak2),
      htmlFlow: opener(html4, buffer3),
      htmlFlowData: onenterdata,
      htmlText: opener(html4, buffer3),
      htmlTextData: onenterdata,
      image: opener(image2),
      label: buffer3,
      link: opener(link2),
      listItem: opener(listItem2),
      listItemValue: onenterlistitemvalue,
      listOrdered: opener(list3, onenterlistordered),
      listUnordered: opener(list3),
      paragraph: opener(paragraph2),
      reference: onenterreference,
      referenceString: buffer3,
      resourceDestinationString: buffer3,
      resourceTitleString: buffer3,
      setextHeading: opener(heading2),
      strong: opener(strong2),
      thematicBreak: opener(thematicBreak3)
    },
    exit: {
      atxHeading: closer(),
      atxHeadingSequence: onexitatxheadingsequence,
      autolink: closer(),
      autolinkEmail: onexitautolinkemail,
      autolinkProtocol: onexitautolinkprotocol,
      blockQuote: closer(),
      characterEscapeValue: onexitdata,
      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
      characterReferenceValue: onexitcharacterreferencevalue,
      codeFenced: closer(onexitcodefenced),
      codeFencedFence: onexitcodefencedfence,
      codeFencedFenceInfo: onexitcodefencedfenceinfo,
      codeFencedFenceMeta: onexitcodefencedfencemeta,
      codeFlowValue: onexitdata,
      codeIndented: closer(onexitcodeindented),
      codeText: closer(onexitcodetext),
      codeTextData: onexitdata,
      data: onexitdata,
      definition: closer(),
      definitionDestinationString: onexitdefinitiondestinationstring,
      definitionLabelString: onexitdefinitionlabelstring,
      definitionTitleString: onexitdefinitiontitlestring,
      emphasis: closer(),
      hardBreakEscape: closer(onexithardbreak),
      hardBreakTrailing: closer(onexithardbreak),
      htmlFlow: closer(onexithtmlflow),
      htmlFlowData: onexitdata,
      htmlText: closer(onexithtmltext),
      htmlTextData: onexitdata,
      image: closer(onexitimage),
      label: onexitlabel,
      labelText: onexitlabeltext,
      lineEnding: onexitlineending,
      link: closer(onexitlink),
      listItem: closer(),
      listOrdered: closer(),
      listUnordered: closer(),
      paragraph: closer(),
      referenceString: onexitreferencestring,
      resourceDestinationString: onexitresourcedestinationstring,
      resourceTitleString: onexitresourcetitlestring,
      resource: onexitresource,
      setextHeading: closer(onexitsetextheading),
      setextHeadingLineSequence: onexitsetextheadinglinesequence,
      setextHeadingText: onexitsetextheadingtext,
      strong: closer(),
      thematicBreak: closer()
    }
  };
  configure(config, (options || {}).mdastExtensions || []);
  const data3 = {};
  return compile3;
  function compile3(events) {
    let tree = {
      type: "root",
      children: []
    };
    const context = {
      stack: [tree],
      tokenStack: [],
      config,
      enter,
      exit: exit2,
      buffer: buffer3,
      resume,
      setData,
      getData
    };
    const listStack = [];
    let index2 = -1;
    while (++index2 < events.length) {
      if (events[index2][1].type === "listOrdered" || events[index2][1].type === "listUnordered") {
        if (events[index2][0] === "enter") {
          listStack.push(index2);
        } else {
          const tail = listStack.pop();
          index2 = prepareList(events, tail, index2);
        }
      }
    }
    index2 = -1;
    while (++index2 < events.length) {
      const handler = config[events[index2][0]];
      if (own4.call(handler, events[index2][1].type)) {
        handler[events[index2][1].type].call(
          Object.assign(
            {
              sliceSerialize: events[index2][2].sliceSerialize
            },
            context
          ),
          events[index2][1]
        );
      }
    }
    if (context.tokenStack.length > 0) {
      const tail = context.tokenStack[context.tokenStack.length - 1];
      const handler = tail[1] || defaultOnError;
      handler.call(context, void 0, tail[0]);
    }
    tree.position = {
      start: point2(
        events.length > 0 ? events[0][1].start : {
          line: 1,
          column: 1,
          offset: 0
        }
      ),
      end: point2(
        events.length > 0 ? events[events.length - 2][1].end : {
          line: 1,
          column: 1,
          offset: 0
        }
      )
    };
    index2 = -1;
    while (++index2 < config.transforms.length) {
      tree = config.transforms[index2](tree) || tree;
    }
    return tree;
  }
  function prepareList(events, start3, length) {
    let index2 = start3 - 1;
    let containerBalance = -1;
    let listSpread = false;
    let listItem3;
    let lineIndex;
    let firstBlankLineIndex;
    let atMarker;
    while (++index2 <= length) {
      const event = events[index2];
      if (event[1].type === "listUnordered" || event[1].type === "listOrdered" || event[1].type === "blockQuote") {
        if (event[0] === "enter") {
          containerBalance++;
        } else {
          containerBalance--;
        }
        atMarker = void 0;
      } else if (event[1].type === "lineEndingBlank") {
        if (event[0] === "enter") {
          if (listItem3 && !atMarker && !containerBalance && !firstBlankLineIndex) {
            firstBlankLineIndex = index2;
          }
          atMarker = void 0;
        }
      } else if (event[1].type === "linePrefix" || event[1].type === "listItemValue" || event[1].type === "listItemMarker" || event[1].type === "listItemPrefix" || event[1].type === "listItemPrefixWhitespace") {
      } else {
        atMarker = void 0;
      }
      if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) {
        if (listItem3) {
          let tailIndex = index2;
          lineIndex = void 0;
          while (tailIndex--) {
            const tailEvent = events[tailIndex];
            if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") {
              if (tailEvent[0] === "exit")
                continue;
              if (lineIndex) {
                events[lineIndex][1].type = "lineEndingBlank";
                listSpread = true;
              }
              tailEvent[1].type = "lineEnding";
              lineIndex = tailIndex;
            } else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") {
            } else {
              break;
            }
          }
          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {
            listItem3._spread = true;
          }
          listItem3.end = Object.assign(
            {},
            lineIndex ? events[lineIndex][1].start : event[1].end
          );
          events.splice(lineIndex || index2, 0, ["exit", listItem3, event[2]]);
          index2++;
          length++;
        }
        if (event[1].type === "listItemPrefix") {
          listItem3 = {
            type: "listItem",
            // @ts-expect-error Patched
            _spread: false,
            start: Object.assign({}, event[1].start)
          };
          events.splice(index2, 0, ["enter", listItem3, event[2]]);
          index2++;
          length++;
          firstBlankLineIndex = void 0;
          atMarker = true;
        }
      }
    }
    events[start3][1]._spread = listSpread;
    return length;
  }
  function setData(key2, value2) {
    data3[key2] = value2;
  }
  function getData(key2) {
    return data3[key2];
  }
  function opener(create4, and) {
    return open;
    function open(token2) {
      enter.call(this, create4(token2), token2);
      if (and)
        and.call(this, token2);
    }
  }
  function buffer3() {
    this.stack.push({
      type: "fragment",
      children: []
    });
  }
  function enter(node2, token2, errorHandler) {
    const parent = this.stack[this.stack.length - 1];
    parent.children.push(node2);
    this.stack.push(node2);
    this.tokenStack.push([token2, errorHandler]);
    node2.position = {
      start: point2(token2.start)
    };
    return node2;
  }
  function closer(and) {
    return close;
    function close(token2) {
      if (and)
        and.call(this, token2);
      exit2.call(this, token2);
    }
  }
  function exit2(token2, onExitError) {
    const node2 = this.stack.pop();
    const open = this.tokenStack.pop();
    if (!open) {
      throw new Error(
        "Cannot close `" + token2.type + "` (" + stringifyPosition({
          start: token2.start,
          end: token2.end
        }) + "): it\u2019s not open"
      );
    } else if (open[0].type !== token2.type) {
      if (onExitError) {
        onExitError.call(this, token2, open[0]);
      } else {
        const handler = open[1] || defaultOnError;
        handler.call(this, token2, open[0]);
      }
    }
    node2.position.end = point2(token2.end);
    return node2;
  }
  function resume() {
    return toString3(this.stack.pop());
  }
  function onenterlistordered() {
    setData("expectingFirstListItemValue", true);
  }
  function onenterlistitemvalue(token2) {
    if (getData("expectingFirstListItemValue")) {
      const ancestor = this.stack[this.stack.length - 2];
      ancestor.start = Number.parseInt(this.sliceSerialize(token2), 10);
      setData("expectingFirstListItemValue");
    }
  }
  function onexitcodefencedfenceinfo() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.lang = data4;
  }
  function onexitcodefencedfencemeta() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.meta = data4;
  }
  function onexitcodefencedfence() {
    if (getData("flowCodeInside"))
      return;
    this.buffer();
    setData("flowCodeInside", true);
  }
  function onexitcodefenced() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.value = data4.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, "");
    setData("flowCodeInside");
  }
  function onexitcodeindented() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.value = data4.replace(/(\r?\n|\r)$/g, "");
  }
  function onexitdefinitionlabelstring(token2) {
    const label = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.label = label;
    node2.identifier = normalizeIdentifier(
      this.sliceSerialize(token2)
    ).toLowerCase();
  }
  function onexitdefinitiontitlestring() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.title = data4;
  }
  function onexitdefinitiondestinationstring() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.url = data4;
  }
  function onexitatxheadingsequence(token2) {
    const node2 = this.stack[this.stack.length - 1];
    if (!node2.depth) {
      const depth = this.sliceSerialize(token2).length;
      node2.depth = depth;
    }
  }
  function onexitsetextheadingtext() {
    setData("setextHeadingSlurpLineEnding", true);
  }
  function onexitsetextheadinglinesequence(token2) {
    const node2 = this.stack[this.stack.length - 1];
    node2.depth = this.sliceSerialize(token2).charCodeAt(0) === 61 ? 1 : 2;
  }
  function onexitsetextheading() {
    setData("setextHeadingSlurpLineEnding");
  }
  function onenterdata(token2) {
    const node2 = this.stack[this.stack.length - 1];
    let tail = node2.children[node2.children.length - 1];
    if (!tail || tail.type !== "text") {
      tail = text5();
      tail.position = {
        start: point2(token2.start)
      };
      node2.children.push(tail);
    }
    this.stack.push(tail);
  }
  function onexitdata(token2) {
    const tail = this.stack.pop();
    tail.value += this.sliceSerialize(token2);
    tail.position.end = point2(token2.end);
  }
  function onexitlineending(token2) {
    const context = this.stack[this.stack.length - 1];
    if (getData("atHardBreak")) {
      const tail = context.children[context.children.length - 1];
      tail.position.end = point2(token2.end);
      setData("atHardBreak");
      return;
    }
    if (!getData("setextHeadingSlurpLineEnding") && config.canContainEols.includes(context.type)) {
      onenterdata.call(this, token2);
      onexitdata.call(this, token2);
    }
  }
  function onexithardbreak() {
    setData("atHardBreak", true);
  }
  function onexithtmlflow() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.value = data4;
  }
  function onexithtmltext() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.value = data4;
  }
  function onexitcodetext() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.value = data4;
  }
  function onexitlink() {
    const node2 = this.stack[this.stack.length - 1];
    if (getData("inReference")) {
      const referenceType = getData("referenceType") || "shortcut";
      node2.type += "Reference";
      node2.referenceType = referenceType;
      delete node2.url;
      delete node2.title;
    } else {
      delete node2.identifier;
      delete node2.label;
    }
    setData("referenceType");
  }
  function onexitimage() {
    const node2 = this.stack[this.stack.length - 1];
    if (getData("inReference")) {
      const referenceType = getData("referenceType") || "shortcut";
      node2.type += "Reference";
      node2.referenceType = referenceType;
      delete node2.url;
      delete node2.title;
    } else {
      delete node2.identifier;
      delete node2.label;
    }
    setData("referenceType");
  }
  function onexitlabeltext(token2) {
    const string3 = this.sliceSerialize(token2);
    const ancestor = this.stack[this.stack.length - 2];
    ancestor.label = decodeString(string3);
    ancestor.identifier = normalizeIdentifier(string3).toLowerCase();
  }
  function onexitlabel() {
    const fragment = this.stack[this.stack.length - 1];
    const value2 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    setData("inReference", true);
    if (node2.type === "link") {
      const children = fragment.children;
      node2.children = children;
    } else {
      node2.alt = value2;
    }
  }
  function onexitresourcedestinationstring() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.url = data4;
  }
  function onexitresourcetitlestring() {
    const data4 = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.title = data4;
  }
  function onexitresource() {
    setData("inReference");
  }
  function onenterreference() {
    setData("referenceType", "collapsed");
  }
  function onexitreferencestring(token2) {
    const label = this.resume();
    const node2 = this.stack[this.stack.length - 1];
    node2.label = label;
    node2.identifier = normalizeIdentifier(
      this.sliceSerialize(token2)
    ).toLowerCase();
    setData("referenceType", "full");
  }
  function onexitcharacterreferencemarker(token2) {
    setData("characterReferenceType", token2.type);
  }
  function onexitcharacterreferencevalue(token2) {
    const data4 = this.sliceSerialize(token2);
    const type = getData("characterReferenceType");
    let value2;
    if (type) {
      value2 = decodeNumericCharacterReference(
        data4,
        type === "characterReferenceMarkerNumeric" ? 10 : 16
      );
      setData("characterReferenceType");
    } else {
      const result = decodeNamedCharacterReference(data4);
      value2 = result;
    }
    const tail = this.stack.pop();
    tail.value += value2;
    tail.position.end = point2(token2.end);
  }
  function onexitautolinkprotocol(token2) {
    onexitdata.call(this, token2);
    const node2 = this.stack[this.stack.length - 1];
    node2.url = this.sliceSerialize(token2);
  }
  function onexitautolinkemail(token2) {
    onexitdata.call(this, token2);
    const node2 = this.stack[this.stack.length - 1];
    node2.url = "mailto:" + this.sliceSerialize(token2);
  }
  function blockQuote2() {
    return {
      type: "blockquote",
      children: []
    };
  }
  function codeFlow() {
    return {
      type: "code",
      lang: null,
      meta: null,
      value: ""
    };
  }
  function codeText2() {
    return {
      type: "inlineCode",
      value: ""
    };
  }
  function definition2() {
    return {
      type: "definition",
      identifier: "",
      label: null,
      title: null,
      url: ""
    };
  }
  function emphasis2() {
    return {
      type: "emphasis",
      children: []
    };
  }
  function heading2() {
    return {
      type: "heading",
      depth: void 0,
      children: []
    };
  }
  function hardBreak2() {
    return {
      type: "break"
    };
  }
  function html4() {
    return {
      type: "html",
      value: ""
    };
  }
  function image2() {
    return {
      type: "image",
      title: null,
      url: "",
      alt: null
    };
  }
  function link2() {
    return {
      type: "link",
      title: null,
      url: "",
      children: []
    };
  }
  function list3(token2) {
    return {
      type: "list",
      ordered: token2.type === "listOrdered",
      start: null,
      // @ts-expect-error Patched.
      spread: token2._spread,
      children: []
    };
  }
  function listItem2(token2) {
    return {
      type: "listItem",
      // @ts-expect-error Patched.
      spread: token2._spread,
      checked: null,
      children: []
    };
  }
  function paragraph2() {
    return {
      type: "paragraph",
      children: []
    };
  }
  function strong2() {
    return {
      type: "strong",
      children: []
    };
  }
  function text5() {
    return {
      type: "text",
      value: ""
    };
  }
  function thematicBreak3() {
    return {
      type: "thematicBreak"
    };
  }
}
function point2(d) {
  return {
    line: d.line,
    column: d.column,
    offset: d.offset
  };
}
function configure(combined, extensions) {
  let index2 = -1;
  while (++index2 < extensions.length) {
    const value2 = extensions[index2];
    if (Array.isArray(value2)) {
      configure(combined, value2);
    } else {
      extension(combined, value2);
    }
  }
}
function extension(combined, extension2) {
  let key2;
  for (key2 in extension2) {
    if (own4.call(extension2, key2)) {
      if (key2 === "canContainEols") {
        const right = extension2[key2];
        if (right) {
          combined[key2].push(...right);
        }
      } else if (key2 === "transforms") {
        const right = extension2[key2];
        if (right) {
          combined[key2].push(...right);
        }
      } else if (key2 === "enter" || key2 === "exit") {
        const right = extension2[key2];
        if (right) {
          Object.assign(combined[key2], right);
        }
      }
    }
  }
}
function defaultOnError(left, right) {
  if (left) {
    throw new Error(
      "Cannot close `" + left.type + "` (" + stringifyPosition({
        start: left.start,
        end: left.end
      }) + "): a different token (`" + right.type + "`, " + stringifyPosition({
        start: right.start,
        end: right.end
      }) + ") is open"
    );
  } else {
    throw new Error(
      "Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({
        start: right.start,
        end: right.end
      }) + ") is still open"
    );
  }
}

// node_modules/remark-parse/lib/index.js
function remarkParse(options) {
  const parser = (doc) => {
    const settings = (
      /** @type {Options} */
      this.data("settings")
    );
    return fromMarkdown(
      doc,
      Object.assign({}, settings, options, {
        // Note: these options are not in the readme.
        // The goal is for them to be set by plugins on `data` instead of being
        // passed by users.
        extensions: this.data("micromarkExtensions") || [],
        mdastExtensions: this.data("fromMarkdownExtensions") || []
      })
    );
  };
  Object.assign(this, { Parser: parser });
}

// node_modules/remark-parse/index.js
var remark_parse_default = remarkParse;

// node_modules/mdast-util-to-hast/lib/handlers/blockquote.js
function blockquote(state, node2) {
  const result = {
    type: "element",
    tagName: "blockquote",
    properties: {},
    children: state.wrap(state.all(node2), true)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/break.js
function hardBreak(state, node2) {
  const result = { type: "element", tagName: "br", properties: {}, children: [] };
  state.patch(node2, result);
  return [state.applyData(node2, result), { type: "text", value: "\n" }];
}

// node_modules/mdast-util-to-hast/lib/handlers/code.js
function code(state, node2) {
  const value2 = node2.value ? node2.value + "\n" : "";
  const lang = node2.lang ? node2.lang.match(/^[^ \t]+(?=[ \t]|$)/) : null;
  const properties = {};
  if (lang) {
    properties.className = ["language-" + lang];
  }
  let result = {
    type: "element",
    tagName: "code",
    properties,
    children: [{ type: "text", value: value2 }]
  };
  if (node2.meta) {
    result.data = { meta: node2.meta };
  }
  state.patch(node2, result);
  result = state.applyData(node2, result);
  result = { type: "element", tagName: "pre", properties: {}, children: [result] };
  state.patch(node2, result);
  return result;
}

// node_modules/mdast-util-to-hast/lib/handlers/delete.js
function strikethrough(state, node2) {
  const result = {
    type: "element",
    tagName: "del",
    properties: {},
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/emphasis.js
function emphasis(state, node2) {
  const result = {
    type: "element",
    tagName: "em",
    properties: {},
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/micromark-util-sanitize-uri/index.js
function normalizeUri(value2) {
  const result = [];
  let index2 = -1;
  let start3 = 0;
  let skip = 0;
  while (++index2 < value2.length) {
    const code2 = value2.charCodeAt(index2);
    let replace = "";
    if (code2 === 37 && asciiAlphanumeric(value2.charCodeAt(index2 + 1)) && asciiAlphanumeric(value2.charCodeAt(index2 + 2))) {
      skip = 2;
    } else if (code2 < 128) {
      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code2))) {
        replace = String.fromCharCode(code2);
      }
    } else if (code2 > 55295 && code2 < 57344) {
      const next = value2.charCodeAt(index2 + 1);
      if (code2 < 56320 && next > 56319 && next < 57344) {
        replace = String.fromCharCode(code2, next);
        skip = 1;
      } else {
        replace = "\uFFFD";
      }
    } else {
      replace = String.fromCharCode(code2);
    }
    if (replace) {
      result.push(value2.slice(start3, index2), encodeURIComponent(replace));
      start3 = index2 + skip + 1;
      replace = "";
    }
    if (skip) {
      index2 += skip;
      skip = 0;
    }
  }
  return result.join("") + value2.slice(start3);
}

// node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js
function footnoteReference(state, node2) {
  const id = String(node2.identifier).toUpperCase();
  const safeId = normalizeUri(id.toLowerCase());
  const index2 = state.footnoteOrder.indexOf(id);
  let counter;
  if (index2 === -1) {
    state.footnoteOrder.push(id);
    state.footnoteCounts[id] = 1;
    counter = state.footnoteOrder.length;
  } else {
    state.footnoteCounts[id]++;
    counter = index2 + 1;
  }
  const reuseCounter = state.footnoteCounts[id];
  const link2 = {
    type: "element",
    tagName: "a",
    properties: {
      href: "#" + state.clobberPrefix + "fn-" + safeId,
      id: state.clobberPrefix + "fnref-" + safeId + (reuseCounter > 1 ? "-" + reuseCounter : ""),
      dataFootnoteRef: true,
      ariaDescribedBy: ["footnote-label"]
    },
    children: [{ type: "text", value: String(counter) }]
  };
  state.patch(node2, link2);
  const sup = {
    type: "element",
    tagName: "sup",
    properties: {},
    children: [link2]
  };
  state.patch(node2, sup);
  return state.applyData(node2, sup);
}

// node_modules/mdast-util-to-hast/lib/handlers/footnote.js
function footnote(state, node2) {
  const footnoteById = state.footnoteById;
  let no = 1;
  while (no in footnoteById)
    no++;
  const identifier = String(no);
  footnoteById[identifier] = {
    type: "footnoteDefinition",
    identifier,
    children: [{ type: "paragraph", children: node2.children }],
    position: node2.position
  };
  return footnoteReference(state, {
    type: "footnoteReference",
    identifier,
    position: node2.position
  });
}

// node_modules/mdast-util-to-hast/lib/handlers/heading.js
function heading(state, node2) {
  const result = {
    type: "element",
    tagName: "h" + node2.depth,
    properties: {},
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/html.js
function html(state, node2) {
  if (state.dangerous) {
    const result = { type: "raw", value: node2.value };
    state.patch(node2, result);
    return state.applyData(node2, result);
  }
  return null;
}

// node_modules/mdast-util-to-hast/lib/revert.js
function revert(state, node2) {
  const subtype = node2.referenceType;
  let suffix = "]";
  if (subtype === "collapsed") {
    suffix += "[]";
  } else if (subtype === "full") {
    suffix += "[" + (node2.label || node2.identifier) + "]";
  }
  if (node2.type === "imageReference") {
    return { type: "text", value: "![" + node2.alt + suffix };
  }
  const contents = state.all(node2);
  const head = contents[0];
  if (head && head.type === "text") {
    head.value = "[" + head.value;
  } else {
    contents.unshift({ type: "text", value: "[" });
  }
  const tail = contents[contents.length - 1];
  if (tail && tail.type === "text") {
    tail.value += suffix;
  } else {
    contents.push({ type: "text", value: suffix });
  }
  return contents;
}

// node_modules/mdast-util-to-hast/lib/handlers/image-reference.js
function imageReference(state, node2) {
  const def = state.definition(node2.identifier);
  if (!def) {
    return revert(state, node2);
  }
  const properties = { src: normalizeUri(def.url || ""), alt: node2.alt };
  if (def.title !== null && def.title !== void 0) {
    properties.title = def.title;
  }
  const result = { type: "element", tagName: "img", properties, children: [] };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/image.js
function image(state, node2) {
  const properties = { src: normalizeUri(node2.url) };
  if (node2.alt !== null && node2.alt !== void 0) {
    properties.alt = node2.alt;
  }
  if (node2.title !== null && node2.title !== void 0) {
    properties.title = node2.title;
  }
  const result = { type: "element", tagName: "img", properties, children: [] };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/inline-code.js
function inlineCode(state, node2) {
  const text5 = { type: "text", value: node2.value.replace(/\r?\n|\r/g, " ") };
  state.patch(node2, text5);
  const result = {
    type: "element",
    tagName: "code",
    properties: {},
    children: [text5]
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/link-reference.js
function linkReference(state, node2) {
  const def = state.definition(node2.identifier);
  if (!def) {
    return revert(state, node2);
  }
  const properties = { href: normalizeUri(def.url || "") };
  if (def.title !== null && def.title !== void 0) {
    properties.title = def.title;
  }
  const result = {
    type: "element",
    tagName: "a",
    properties,
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/link.js
function link(state, node2) {
  const properties = { href: normalizeUri(node2.url) };
  if (node2.title !== null && node2.title !== void 0) {
    properties.title = node2.title;
  }
  const result = {
    type: "element",
    tagName: "a",
    properties,
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/list-item.js
function listItem(state, node2, parent) {
  const results = state.all(node2);
  const loose = parent ? listLoose(parent) : listItemLoose(node2);
  const properties = {};
  const children = [];
  if (typeof node2.checked === "boolean") {
    const head = results[0];
    let paragraph2;
    if (head && head.type === "element" && head.tagName === "p") {
      paragraph2 = head;
    } else {
      paragraph2 = { type: "element", tagName: "p", properties: {}, children: [] };
      results.unshift(paragraph2);
    }
    if (paragraph2.children.length > 0) {
      paragraph2.children.unshift({ type: "text", value: " " });
    }
    paragraph2.children.unshift({
      type: "element",
      tagName: "input",
      properties: { type: "checkbox", checked: node2.checked, disabled: true },
      children: []
    });
    properties.className = ["task-list-item"];
  }
  let index2 = -1;
  while (++index2 < results.length) {
    const child = results[index2];
    if (loose || index2 !== 0 || child.type !== "element" || child.tagName !== "p") {
      children.push({ type: "text", value: "\n" });
    }
    if (child.type === "element" && child.tagName === "p" && !loose) {
      children.push(...child.children);
    } else {
      children.push(child);
    }
  }
  const tail = results[results.length - 1];
  if (tail && (loose || tail.type !== "element" || tail.tagName !== "p")) {
    children.push({ type: "text", value: "\n" });
  }
  const result = { type: "element", tagName: "li", properties, children };
  state.patch(node2, result);
  return state.applyData(node2, result);
}
function listLoose(node2) {
  let loose = false;
  if (node2.type === "list") {
    loose = node2.spread || false;
    const children = node2.children;
    let index2 = -1;
    while (!loose && ++index2 < children.length) {
      loose = listItemLoose(children[index2]);
    }
  }
  return loose;
}
function listItemLoose(node2) {
  const spread = node2.spread;
  return spread === void 0 || spread === null ? node2.children.length > 1 : spread;
}

// node_modules/mdast-util-to-hast/lib/handlers/list.js
function list2(state, node2) {
  const properties = {};
  const results = state.all(node2);
  let index2 = -1;
  if (typeof node2.start === "number" && node2.start !== 1) {
    properties.start = node2.start;
  }
  while (++index2 < results.length) {
    const child = results[index2];
    if (child.type === "element" && child.tagName === "li" && child.properties && Array.isArray(child.properties.className) && child.properties.className.includes("task-list-item")) {
      properties.className = ["contains-task-list"];
      break;
    }
  }
  const result = {
    type: "element",
    tagName: node2.ordered ? "ol" : "ul",
    properties,
    children: state.wrap(results, true)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/paragraph.js
function paragraph(state, node2) {
  const result = {
    type: "element",
    tagName: "p",
    properties: {},
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/root.js
function root(state, node2) {
  const result = { type: "root", children: state.wrap(state.all(node2)) };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/strong.js
function strong(state, node2) {
  const result = {
    type: "element",
    tagName: "strong",
    properties: {},
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/unist-util-position/lib/index.js
var pointStart = point3("start");
var pointEnd = point3("end");
function position2(node2) {
  return { start: pointStart(node2), end: pointEnd(node2) };
}
function point3(type) {
  return point4;
  function point4(node2) {
    const point5 = node2 && node2.position && node2.position[type] || {};
    return {
      // @ts-expect-error: in practice, null is allowed.
      line: point5.line || null,
      // @ts-expect-error: in practice, null is allowed.
      column: point5.column || null,
      // @ts-expect-error: in practice, null is allowed.
      offset: point5.offset > -1 ? point5.offset : null
    };
  }
}

// node_modules/mdast-util-to-hast/lib/handlers/table.js
function table(state, node2) {
  const rows = state.all(node2);
  const firstRow = rows.shift();
  const tableContent = [];
  if (firstRow) {
    const head = {
      type: "element",
      tagName: "thead",
      properties: {},
      children: state.wrap([firstRow], true)
    };
    state.patch(node2.children[0], head);
    tableContent.push(head);
  }
  if (rows.length > 0) {
    const body = {
      type: "element",
      tagName: "tbody",
      properties: {},
      children: state.wrap(rows, true)
    };
    const start3 = pointStart(node2.children[1]);
    const end = pointEnd(node2.children[node2.children.length - 1]);
    if (start3.line && end.line)
      body.position = { start: start3, end };
    tableContent.push(body);
  }
  const result = {
    type: "element",
    tagName: "table",
    properties: {},
    children: state.wrap(tableContent, true)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/table-row.js
function tableRow(state, node2, parent) {
  const siblings = parent ? parent.children : void 0;
  const rowIndex = siblings ? siblings.indexOf(node2) : 1;
  const tagName = rowIndex === 0 ? "th" : "td";
  const align = parent && parent.type === "table" ? parent.align : void 0;
  const length = align ? align.length : node2.children.length;
  let cellIndex = -1;
  const cells = [];
  while (++cellIndex < length) {
    const cell = node2.children[cellIndex];
    const properties = {};
    const alignValue = align ? align[cellIndex] : void 0;
    if (alignValue) {
      properties.align = alignValue;
    }
    let result2 = { type: "element", tagName, properties, children: [] };
    if (cell) {
      result2.children = state.all(cell);
      state.patch(cell, result2);
      result2 = state.applyData(node2, result2);
    }
    cells.push(result2);
  }
  const result = {
    type: "element",
    tagName: "tr",
    properties: {},
    children: state.wrap(cells, true)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/table-cell.js
function tableCell(state, node2) {
  const result = {
    type: "element",
    tagName: "td",
    // Assume body cell.
    properties: {},
    children: state.all(node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/trim-lines/index.js
var tab = 9;
var space = 32;
function trimLines(value2) {
  const source2 = String(value2);
  const search2 = /\r?\n|\r/g;
  let match = search2.exec(source2);
  let last = 0;
  const lines = [];
  while (match) {
    lines.push(
      trimLine(source2.slice(last, match.index), last > 0, true),
      match[0]
    );
    last = match.index + match[0].length;
    match = search2.exec(source2);
  }
  lines.push(trimLine(source2.slice(last), last > 0, false));
  return lines.join("");
}
function trimLine(value2, start3, end) {
  let startIndex = 0;
  let endIndex = value2.length;
  if (start3) {
    let code2 = value2.codePointAt(startIndex);
    while (code2 === tab || code2 === space) {
      startIndex++;
      code2 = value2.codePointAt(startIndex);
    }
  }
  if (end) {
    let code2 = value2.codePointAt(endIndex - 1);
    while (code2 === tab || code2 === space) {
      endIndex--;
      code2 = value2.codePointAt(endIndex - 1);
    }
  }
  return endIndex > startIndex ? value2.slice(startIndex, endIndex) : "";
}

// node_modules/mdast-util-to-hast/lib/handlers/text.js
function text3(state, node2) {
  const result = { type: "text", value: trimLines(String(node2.value)) };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js
function thematicBreak2(state, node2) {
  const result = {
    type: "element",
    tagName: "hr",
    properties: {},
    children: []
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}

// node_modules/mdast-util-to-hast/lib/handlers/index.js
var handlers = {
  blockquote,
  break: hardBreak,
  code,
  delete: strikethrough,
  emphasis,
  footnoteReference,
  footnote,
  heading,
  html,
  imageReference,
  image,
  inlineCode,
  linkReference,
  link,
  listItem,
  list: list2,
  paragraph,
  root,
  strong,
  table,
  tableCell,
  tableRow,
  text: text3,
  thematicBreak: thematicBreak2,
  toml: ignore,
  yaml: ignore,
  definition: ignore,
  footnoteDefinition: ignore
};
function ignore() {
  return null;
}

// node_modules/unist-util-is/lib/index.js
var convert = (
  /**
   * @type {(
   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &
   *   ((test?: Test) => AssertAnything)
   * )}
   */
  /**
   * @param {Test} [test]
   * @returns {AssertAnything}
   */
  function(test) {
    if (test === void 0 || test === null) {
      return ok;
    }
    if (typeof test === "string") {
      return typeFactory(test);
    }
    if (typeof test === "object") {
      return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
    }
    if (typeof test === "function") {
      return castFactory(test);
    }
    throw new Error("Expected function, string, or object as test");
  }
);
function anyFactory(tests) {
  const checks2 = [];
  let index2 = -1;
  while (++index2 < tests.length) {
    checks2[index2] = convert(tests[index2]);
  }
  return castFactory(any);
  function any(...parameters) {
    let index3 = -1;
    while (++index3 < checks2.length) {
      if (checks2[index3].call(this, ...parameters))
        return true;
    }
    return false;
  }
}
function propsFactory(check) {
  return castFactory(all4);
  function all4(node2) {
    let key2;
    for (key2 in check) {
      if (node2[key2] !== check[key2])
        return false;
    }
    return true;
  }
}
function typeFactory(check) {
  return castFactory(type);
  function type(node2) {
    return node2 && node2.type === check;
  }
}
function castFactory(check) {
  return assertion;
  function assertion(node2, ...parameters) {
    return Boolean(
      node2 && typeof node2 === "object" && "type" in node2 && // @ts-expect-error: fine.
      Boolean(check.call(this, node2, ...parameters))
    );
  }
}
function ok() {
  return true;
}

// node_modules/unist-util-visit-parents/lib/color.js
function color2(d) {
  return "\x1B[33m" + d + "\x1B[39m";
}

// node_modules/unist-util-visit-parents/lib/index.js
var CONTINUE2 = true;
var EXIT2 = false;
var SKIP2 = "skip";
var visitParents = (
  /**
   * @type {(
   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
   * )}
   */
  /**
   * @param {Node} tree
   * @param {Test} test
   * @param {Visitor<Node>} visitor
   * @param {boolean | null | undefined} [reverse]
   * @returns {void}
   */
  function(tree, test, visitor, reverse) {
    if (typeof test === "function" && typeof visitor !== "function") {
      reverse = visitor;
      visitor = test;
      test = null;
    }
    const is2 = convert(test);
    const step = reverse ? -1 : 1;
    factory(tree, void 0, [])();
    function factory(node2, index2, parents) {
      const value2 = node2 && typeof node2 === "object" ? node2 : {};
      if (typeof value2.type === "string") {
        const name2 = (
          // `hast`
          typeof value2.tagName === "string" ? value2.tagName : (
            // `xast`
            typeof value2.name === "string" ? value2.name : void 0
          )
        );
        Object.defineProperty(visit3, "name", {
          value: "node (" + color2(node2.type + (name2 ? "<" + name2 + ">" : "")) + ")"
        });
      }
      return visit3;
      function visit3() {
        let result = [];
        let subresult;
        let offset3;
        let grandparents;
        if (!test || is2(node2, index2, parents[parents.length - 1] || null)) {
          result = toResult2(visitor(node2, parents));
          if (result[0] === EXIT2) {
            return result;
          }
        }
        if (node2.children && result[0] !== SKIP2) {
          offset3 = (reverse ? node2.children.length : -1) + step;
          grandparents = parents.concat(node2);
          while (offset3 > -1 && offset3 < node2.children.length) {
            subresult = factory(node2.children[offset3], offset3, grandparents)();
            if (subresult[0] === EXIT2) {
              return subresult;
            }
            offset3 = typeof subresult[1] === "number" ? subresult[1] : offset3 + step;
          }
        }
        return result;
      }
    }
  }
);
function toResult2(value2) {
  if (Array.isArray(value2)) {
    return value2;
  }
  if (typeof value2 === "number") {
    return [CONTINUE2, value2];
  }
  return [value2];
}

// node_modules/unist-util-visit/lib/index.js
var visit2 = (
  /**
   * @type {(
   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
   * )}
   */
  /**
   * @param {Node} tree
   * @param {Test} test
   * @param {Visitor} visitor
   * @param {boolean | null | undefined} [reverse]
   * @returns {void}
   */
  function(tree, test, visitor, reverse) {
    if (typeof test === "function" && typeof visitor !== "function") {
      reverse = visitor;
      visitor = test;
      test = null;
    }
    visitParents(tree, test, overload, reverse);
    function overload(node2, parents) {
      const parent = parents[parents.length - 1];
      return visitor(
        node2,
        parent ? parent.children.indexOf(node2) : null,
        parent
      );
    }
  }
);

// node_modules/unist-util-generated/lib/index.js
function generated(node2) {
  return !node2 || !node2.position || !node2.position.start || !node2.position.start.line || !node2.position.start.column || !node2.position.end || !node2.position.end.line || !node2.position.end.column;
}

// node_modules/mdast-util-to-hast/node_modules/mdast-util-definitions/lib/index.js
var own5 = {}.hasOwnProperty;
function definitions(tree) {
  const cache = /* @__PURE__ */ Object.create(null);
  if (!tree || !tree.type) {
    throw new Error("mdast-util-definitions expected node");
  }
  visit2(tree, "definition", (definition3) => {
    const id = clean(definition3.identifier);
    if (id && !own5.call(cache, id)) {
      cache[id] = definition3;
    }
  });
  return definition2;
  function definition2(identifier) {
    const id = clean(identifier);
    return id && own5.call(cache, id) ? cache[id] : null;
  }
}
function clean(value2) {
  return String(value2 || "").toUpperCase();
}

// node_modules/mdast-util-to-hast/lib/state.js
var own6 = {}.hasOwnProperty;
function createState(tree, options) {
  const settings = options || {};
  const dangerous = settings.allowDangerousHtml || false;
  const footnoteById = {};
  state.dangerous = dangerous;
  state.clobberPrefix = settings.clobberPrefix === void 0 || settings.clobberPrefix === null ? "user-content-" : settings.clobberPrefix;
  state.footnoteLabel = settings.footnoteLabel || "Footnotes";
  state.footnoteLabelTagName = settings.footnoteLabelTagName || "h2";
  state.footnoteLabelProperties = settings.footnoteLabelProperties || {
    className: ["sr-only"]
  };
  state.footnoteBackLabel = settings.footnoteBackLabel || "Back to content";
  state.unknownHandler = settings.unknownHandler;
  state.passThrough = settings.passThrough;
  state.handlers = { ...handlers, ...settings.handlers };
  state.definition = definitions(tree);
  state.footnoteById = footnoteById;
  state.footnoteOrder = [];
  state.footnoteCounts = {};
  state.patch = patch;
  state.applyData = applyData;
  state.one = oneBound;
  state.all = allBound;
  state.wrap = wrap2;
  state.augment = augment;
  visit2(tree, "footnoteDefinition", (definition2) => {
    const id = String(definition2.identifier).toUpperCase();
    if (!own6.call(footnoteById, id)) {
      footnoteById[id] = definition2;
    }
  });
  return state;
  function augment(left, right) {
    if (left && "data" in left && left.data) {
      const data3 = left.data;
      if (data3.hName) {
        if (right.type !== "element") {
          right = {
            type: "element",
            tagName: "",
            properties: {},
            children: []
          };
        }
        right.tagName = data3.hName;
      }
      if (right.type === "element" && data3.hProperties) {
        right.properties = { ...right.properties, ...data3.hProperties };
      }
      if ("children" in right && right.children && data3.hChildren) {
        right.children = data3.hChildren;
      }
    }
    if (left) {
      const ctx = "type" in left ? left : { position: left };
      if (!generated(ctx)) {
        right.position = { start: pointStart(ctx), end: pointEnd(ctx) };
      }
    }
    return right;
  }
  function state(node2, tagName, props, children) {
    if (Array.isArray(props)) {
      children = props;
      props = {};
    }
    return augment(node2, {
      type: "element",
      tagName,
      properties: props || {},
      children: children || []
    });
  }
  function oneBound(node2, parent) {
    return one2(state, node2, parent);
  }
  function allBound(parent) {
    return all2(state, parent);
  }
}
function patch(from, to) {
  if (from.position)
    to.position = position2(from);
}
function applyData(from, to) {
  let result = to;
  if (from && from.data) {
    const hName = from.data.hName;
    const hChildren = from.data.hChildren;
    const hProperties = from.data.hProperties;
    if (typeof hName === "string") {
      if (result.type === "element") {
        result.tagName = hName;
      } else {
        result = {
          type: "element",
          tagName: hName,
          properties: {},
          children: []
        };
      }
    }
    if (result.type === "element" && hProperties) {
      result.properties = { ...result.properties, ...hProperties };
    }
    if ("children" in result && result.children && hChildren !== null && hChildren !== void 0) {
      result.children = hChildren;
    }
  }
  return result;
}
function one2(state, node2, parent) {
  const type = node2 && node2.type;
  if (!type) {
    throw new Error("Expected node, got `" + node2 + "`");
  }
  if (own6.call(state.handlers, type)) {
    return state.handlers[type](state, node2, parent);
  }
  if (state.passThrough && state.passThrough.includes(type)) {
    return "children" in node2 ? { ...node2, children: all2(state, node2) } : node2;
  }
  if (state.unknownHandler) {
    return state.unknownHandler(state, node2, parent);
  }
  return defaultUnknownHandler(state, node2);
}
function all2(state, parent) {
  const values = [];
  if ("children" in parent) {
    const nodes = parent.children;
    let index2 = -1;
    while (++index2 < nodes.length) {
      const result = one2(state, nodes[index2], parent);
      if (result) {
        if (index2 && nodes[index2 - 1].type === "break") {
          if (!Array.isArray(result) && result.type === "text") {
            result.value = result.value.replace(/^\s+/, "");
          }
          if (!Array.isArray(result) && result.type === "element") {
            const head = result.children[0];
            if (head && head.type === "text") {
              head.value = head.value.replace(/^\s+/, "");
            }
          }
        }
        if (Array.isArray(result)) {
          values.push(...result);
        } else {
          values.push(result);
        }
      }
    }
  }
  return values;
}
function defaultUnknownHandler(state, node2) {
  const data3 = node2.data || {};
  const result = "value" in node2 && !(own6.call(data3, "hProperties") || own6.call(data3, "hChildren")) ? { type: "text", value: node2.value } : {
    type: "element",
    tagName: "div",
    properties: {},
    children: all2(state, node2)
  };
  state.patch(node2, result);
  return state.applyData(node2, result);
}
function wrap2(nodes, loose) {
  const result = [];
  let index2 = -1;
  if (loose) {
    result.push({ type: "text", value: "\n" });
  }
  while (++index2 < nodes.length) {
    if (index2)
      result.push({ type: "text", value: "\n" });
    result.push(nodes[index2]);
  }
  if (loose && nodes.length > 0) {
    result.push({ type: "text", value: "\n" });
  }
  return result;
}

// node_modules/mdast-util-to-hast/lib/footer.js
function footer(state) {
  const listItems = [];
  let index2 = -1;
  while (++index2 < state.footnoteOrder.length) {
    const def = state.footnoteById[state.footnoteOrder[index2]];
    if (!def) {
      continue;
    }
    const content3 = state.all(def);
    const id = String(def.identifier).toUpperCase();
    const safeId = normalizeUri(id.toLowerCase());
    let referenceIndex = 0;
    const backReferences = [];
    while (++referenceIndex <= state.footnoteCounts[id]) {
      const backReference = {
        type: "element",
        tagName: "a",
        properties: {
          href: "#" + state.clobberPrefix + "fnref-" + safeId + (referenceIndex > 1 ? "-" + referenceIndex : ""),
          dataFootnoteBackref: true,
          className: ["data-footnote-backref"],
          ariaLabel: state.footnoteBackLabel
        },
        children: [{ type: "text", value: "\u21A9" }]
      };
      if (referenceIndex > 1) {
        backReference.children.push({
          type: "element",
          tagName: "sup",
          children: [{ type: "text", value: String(referenceIndex) }]
        });
      }
      if (backReferences.length > 0) {
        backReferences.push({ type: "text", value: " " });
      }
      backReferences.push(backReference);
    }
    const tail = content3[content3.length - 1];
    if (tail && tail.type === "element" && tail.tagName === "p") {
      const tailTail = tail.children[tail.children.length - 1];
      if (tailTail && tailTail.type === "text") {
        tailTail.value += " ";
      } else {
        tail.children.push({ type: "text", value: " " });
      }
      tail.children.push(...backReferences);
    } else {
      content3.push(...backReferences);
    }
    const listItem2 = {
      type: "element",
      tagName: "li",
      properties: { id: state.clobberPrefix + "fn-" + safeId },
      children: state.wrap(content3, true)
    };
    state.patch(def, listItem2);
    listItems.push(listItem2);
  }
  if (listItems.length === 0) {
    return;
  }
  return {
    type: "element",
    tagName: "section",
    properties: { dataFootnotes: true, className: ["footnotes"] },
    children: [
      {
        type: "element",
        tagName: state.footnoteLabelTagName,
        properties: {
          // To do: use structured clone.
          ...JSON.parse(JSON.stringify(state.footnoteLabelProperties)),
          id: "footnote-label"
        },
        children: [{ type: "text", value: state.footnoteLabel }]
      },
      { type: "text", value: "\n" },
      {
        type: "element",
        tagName: "ol",
        properties: {},
        children: state.wrap(listItems, true)
      },
      { type: "text", value: "\n" }
    ]
  };
}

// node_modules/mdast-util-to-hast/lib/index.js
function toHast(tree, options) {
  const state = createState(tree, options);
  const node2 = state.one(tree, null);
  const foot = footer(state);
  if (foot) {
    node2.children.push({ type: "text", value: "\n" }, foot);
  }
  return Array.isArray(node2) ? { type: "root", children: node2 } : node2;
}

// node_modules/remark-rehype/lib/index.js
var remarkRehype = (
  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */
  function(destination, options) {
    return destination && "run" in destination ? bridge(destination, options) : mutate(destination || options);
  }
);
var lib_default = remarkRehype;
function bridge(destination, options) {
  return (node2, file, next) => {
    destination.run(toHast(node2, options), file, (error) => {
      next(error);
    });
  };
}
function mutate(options) {
  return (node2) => toHast(node2, options);
}

// node_modules/estree-walker/src/walker.js
var WalkerBase = class {
  constructor() {
    this.should_skip = false;
    this.should_remove = false;
    this.replacement = null;
    this.context = {
      skip: () => this.should_skip = true,
      remove: () => this.should_remove = true,
      replace: (node2) => this.replacement = node2
    };
  }
  /**
   * @template {Node} Parent
   * @param {Parent | null | undefined} parent
   * @param {keyof Parent | null | undefined} prop
   * @param {number | null | undefined} index
   * @param {Node} node
   */
  replace(parent, prop, index2, node2) {
    if (parent && prop) {
      if (index2 != null) {
        parent[prop][index2] = node2;
      } else {
        parent[prop] = node2;
      }
    }
  }
  /**
   * @template {Node} Parent
   * @param {Parent | null | undefined} parent
   * @param {keyof Parent | null | undefined} prop
   * @param {number | null | undefined} index
   */
  remove(parent, prop, index2) {
    if (parent && prop) {
      if (index2 !== null && index2 !== void 0) {
        parent[prop].splice(index2, 1);
      } else {
        delete parent[prop];
      }
    }
  }
};

// node_modules/estree-walker/src/sync.js
var SyncWalker = class extends WalkerBase {
  /**
   *
   * @param {SyncHandler} [enter]
   * @param {SyncHandler} [leave]
   */
  constructor(enter, leave) {
    super();
    this.should_skip = false;
    this.should_remove = false;
    this.replacement = null;
    this.context = {
      skip: () => this.should_skip = true,
      remove: () => this.should_remove = true,
      replace: (node2) => this.replacement = node2
    };
    this.enter = enter;
    this.leave = leave;
  }
  /**
   * @template {Node} Parent
   * @param {Node} node
   * @param {Parent | null} parent
   * @param {keyof Parent} [prop]
   * @param {number | null} [index]
   * @returns {Node | null}
   */
  visit(node2, parent, prop, index2) {
    if (node2) {
      if (this.enter) {
        const _should_skip = this.should_skip;
        const _should_remove = this.should_remove;
        const _replacement = this.replacement;
        this.should_skip = false;
        this.should_remove = false;
        this.replacement = null;
        this.enter.call(this.context, node2, parent, prop, index2);
        if (this.replacement) {
          node2 = this.replacement;
          this.replace(parent, prop, index2, node2);
        }
        if (this.should_remove) {
          this.remove(parent, prop, index2);
        }
        const skipped = this.should_skip;
        const removed = this.should_remove;
        this.should_skip = _should_skip;
        this.should_remove = _should_remove;
        this.replacement = _replacement;
        if (skipped)
          return node2;
        if (removed)
          return null;
      }
      let key2;
      for (key2 in node2) {
        const value2 = node2[key2];
        if (value2 && typeof value2 === "object") {
          if (Array.isArray(value2)) {
            const nodes = (
              /** @type {Array<unknown>} */
              value2
            );
            for (let i = 0; i < nodes.length; i += 1) {
              const item = nodes[i];
              if (isNode(item)) {
                if (!this.visit(item, node2, key2, i)) {
                  i--;
                }
              }
            }
          } else if (isNode(value2)) {
            this.visit(value2, node2, key2, null);
          }
        }
      }
      if (this.leave) {
        const _replacement = this.replacement;
        const _should_remove = this.should_remove;
        this.replacement = null;
        this.should_remove = false;
        this.leave.call(this.context, node2, parent, prop, index2);
        if (this.replacement) {
          node2 = this.replacement;
          this.replace(parent, prop, index2, node2);
        }
        if (this.should_remove) {
          this.remove(parent, prop, index2);
        }
        const removed = this.should_remove;
        this.replacement = _replacement;
        this.should_remove = _should_remove;
        if (removed)
          return null;
      }
    }
    return node2;
  }
};
function isNode(value2) {
  return value2 !== null && typeof value2 === "object" && "type" in value2 && typeof value2.type === "string";
}

// node_modules/estree-walker/src/index.js
function walk(ast, { enter, leave }) {
  const instance = new SyncWalker(enter, leave);
  return instance.visit(ast, null);
}

// node_modules/estree-util-build-jsx/lib/index.js
var regex = /@(jsx|jsxFrag|jsxImportSource|jsxRuntime)\s+(\S+)/g;
function buildJsx(tree, options) {
  const config = options || {};
  let automatic = config.runtime === "automatic";
  const annotations = {};
  const imports = {};
  walk(tree, {
    // @ts-expect-error: hush, `estree-walker` is broken.
    enter(node2) {
      if (node2.type === "Program") {
        const comments = node2.comments || [];
        let index2 = -1;
        while (++index2 < comments.length) {
          regex.lastIndex = 0;
          let match = regex.exec(comments[index2].value);
          while (match) {
            annotations[match[1]] = match[2];
            match = regex.exec(comments[index2].value);
          }
        }
        if (annotations.jsxRuntime) {
          if (annotations.jsxRuntime === "automatic") {
            automatic = true;
            if (annotations.jsx) {
              throw new Error("Unexpected `@jsx` pragma w/ automatic runtime");
            }
            if (annotations.jsxFrag) {
              throw new Error(
                "Unexpected `@jsxFrag` pragma w/ automatic runtime"
              );
            }
          } else if (annotations.jsxRuntime === "classic") {
            automatic = false;
            if (annotations.jsxImportSource) {
              throw new Error(
                "Unexpected `@jsxImportSource` w/ classic runtime"
              );
            }
          } else {
            throw new Error(
              "Unexpected `jsxRuntime` `" + annotations.jsxRuntime + "`, expected `automatic` or `classic`"
            );
          }
        }
      }
    },
    // @ts-expect-error: hush, `estree-walker` is broken.
    // eslint-disable-next-line complexity
    leave(node2) {
      if (node2.type === "Program") {
        const specifiers = [];
        if (imports.fragment) {
          specifiers.push({
            type: "ImportSpecifier",
            imported: { type: "Identifier", name: "Fragment" },
            local: { type: "Identifier", name: "_Fragment" }
          });
        }
        if (imports.jsx) {
          specifiers.push({
            type: "ImportSpecifier",
            imported: { type: "Identifier", name: "jsx" },
            local: { type: "Identifier", name: "_jsx" }
          });
        }
        if (imports.jsxs) {
          specifiers.push({
            type: "ImportSpecifier",
            imported: { type: "Identifier", name: "jsxs" },
            local: { type: "Identifier", name: "_jsxs" }
          });
        }
        if (imports.jsxDEV) {
          specifiers.push({
            type: "ImportSpecifier",
            imported: { type: "Identifier", name: "jsxDEV" },
            local: { type: "Identifier", name: "_jsxDEV" }
          });
        }
        if (specifiers.length > 0) {
          node2.body.unshift({
            type: "ImportDeclaration",
            specifiers,
            source: {
              type: "Literal",
              value: (annotations.jsxImportSource || config.importSource || "react") + (config.development ? "/jsx-dev-runtime" : "/jsx-runtime")
            }
          });
        }
      }
      if (node2.type !== "JSXElement" && node2.type !== "JSXFragment") {
        return;
      }
      const children = [];
      let index2 = -1;
      while (++index2 < node2.children.length) {
        const child = node2.children[index2];
        if (child.type === "JSXExpressionContainer") {
          if (child.expression.type !== "JSXEmptyExpression") {
            children.push(child.expression);
          }
        } else if (child.type === "JSXText") {
          const value2 = child.value.replace(/\t/g, " ").replace(/ *(\r?\n|\r) */g, "\n").replace(/\n+/g, "\n").replace(/\n+$/, "").replace(/^\n+/, "").replace(/\n/g, " ");
          if (value2) {
            children.push(create(child, { type: "Literal", value: value2 }));
          }
        } else {
          children.push(child);
        }
      }
      let name2;
      let fields = [];
      const objects = [];
      let parameters = [];
      let key2;
      if (node2.type === "JSXElement") {
        name2 = toIdentifier(node2.openingElement.name);
        if (name2.type === "Identifier" && /^[a-z]/.test(name2.name)) {
          name2 = create(name2, { type: "Literal", value: name2.name });
        }
        let spread;
        const attributes = node2.openingElement.attributes;
        let index3 = -1;
        while (++index3 < attributes.length) {
          const attribute = attributes[index3];
          if (attribute.type === "JSXSpreadAttribute") {
            if (fields.length > 0) {
              objects.push({ type: "ObjectExpression", properties: fields });
              fields = [];
            }
            objects.push(attribute.argument);
            spread = true;
          } else {
            const prop = toProperty(attribute);
            if (automatic && prop.key.type === "Identifier" && prop.key.name === "key") {
              if (spread) {
                throw new Error(
                  "Expected `key` to come before any spread expressions"
                );
              }
              key2 = prop.value;
            } else {
              fields.push(prop);
            }
          }
        }
      } else if (automatic) {
        imports.fragment = true;
        name2 = { type: "Identifier", name: "_Fragment" };
      } else {
        name2 = toMemberExpression(
          annotations.jsxFrag || config.pragmaFrag || "React.Fragment"
        );
      }
      if (automatic) {
        if (children.length > 0) {
          fields.push({
            type: "Property",
            key: { type: "Identifier", name: "children" },
            value: children.length > 1 ? { type: "ArrayExpression", elements: children } : children[0],
            kind: "init",
            method: false,
            shorthand: false,
            computed: false
          });
        }
      } else {
        parameters = children;
      }
      if (fields.length > 0) {
        objects.push({ type: "ObjectExpression", properties: fields });
      }
      let props;
      let callee;
      if (objects.length > 1) {
        if (objects[0].type !== "ObjectExpression") {
          objects.unshift({ type: "ObjectExpression", properties: [] });
        }
        props = {
          type: "CallExpression",
          callee: toMemberExpression("Object.assign"),
          arguments: objects,
          optional: false
        };
      } else if (objects.length > 0) {
        props = objects[0];
      }
      if (automatic) {
        parameters.push(props || { type: "ObjectExpression", properties: [] });
        if (key2) {
          parameters.push(key2);
        } else if (config.development) {
          parameters.push({ type: "Identifier", name: "undefined" });
        }
        const isStaticChildren = children.length > 1;
        if (config.development) {
          imports.jsxDEV = true;
          callee = {
            type: "Identifier",
            name: "_jsxDEV"
          };
          parameters.push({ type: "Literal", value: isStaticChildren });
          const source2 = {
            type: "ObjectExpression",
            properties: [
              {
                type: "Property",
                method: false,
                shorthand: false,
                computed: false,
                kind: "init",
                key: { type: "Identifier", name: "fileName" },
                value: {
                  type: "Literal",
                  value: config.filePath || "<source.js>"
                }
              }
            ]
          };
          if (node2.loc) {
            source2.properties.push(
              {
                type: "Property",
                method: false,
                shorthand: false,
                computed: false,
                kind: "init",
                key: { type: "Identifier", name: "lineNumber" },
                value: { type: "Literal", value: node2.loc.start.line }
              },
              {
                type: "Property",
                method: false,
                shorthand: false,
                computed: false,
                kind: "init",
                key: { type: "Identifier", name: "columnNumber" },
                value: { type: "Literal", value: node2.loc.start.column + 1 }
              }
            );
          }
          parameters.push(source2, { type: "ThisExpression" });
        } else if (isStaticChildren) {
          imports.jsxs = true;
          callee = { type: "Identifier", name: "_jsxs" };
        } else {
          imports.jsx = true;
          callee = { type: "Identifier", name: "_jsx" };
        }
      } else {
        if (props || parameters.length > 0) {
          parameters.unshift(props || { type: "Literal", value: null });
        }
        callee = toMemberExpression(
          annotations.jsx || config.pragma || "React.createElement"
        );
      }
      parameters.unshift(name2);
      this.replace(
        create(node2, {
          type: "CallExpression",
          callee,
          arguments: parameters,
          optional: false
        })
      );
    }
  });
  return tree;
}
function toProperty(node2) {
  let value2;
  if (node2.value) {
    if (node2.value.type === "JSXExpressionContainer") {
      value2 = node2.value.expression;
    } else {
      value2 = node2.value;
      delete value2.raw;
    }
  } else {
    value2 = { type: "Literal", value: true };
  }
  return create(node2, {
    type: "Property",
    key: toIdentifier(node2.name),
    value: value2,
    kind: "init",
    method: false,
    shorthand: false,
    computed: false
  });
}
function toIdentifier(node2) {
  let replace;
  if (node2.type === "JSXMemberExpression") {
    const id = toIdentifier(node2.property);
    replace = {
      type: "MemberExpression",
      object: toIdentifier(node2.object),
      property: id,
      computed: id.type === "Literal",
      optional: false
    };
  } else if (node2.type === "JSXNamespacedName") {
    replace = {
      type: "Literal",
      value: node2.namespace.name + ":" + node2.name.name
    };
  } else {
    replace = name(node2.name) ? { type: "Identifier", name: node2.name } : { type: "Literal", value: node2.name };
  }
  return create(node2, replace);
}
function toMemberExpression(id) {
  const identifiers = id.split(".");
  let index2 = -1;
  let result;
  while (++index2 < identifiers.length) {
    const prop = name(identifiers[index2]) ? { type: "Identifier", name: identifiers[index2] } : { type: "Literal", value: identifiers[index2] };
    result = result ? {
      type: "MemberExpression",
      object: result,
      property: prop,
      computed: Boolean(index2 && prop.type === "Literal"),
      optional: false
    } : prop;
  }
  return result;
}
function create(from, node2) {
  const fields = ["start", "end", "loc", "range", "comments"];
  let index2 = -1;
  while (++index2 < fields.length) {
    const field = fields[index2];
    if (field in from) {
      node2[field] = from[field];
    }
  }
  return node2;
}

// node_modules/@mdx-js/mdx/lib/util/estree-util-create.js
function create2(from, to) {
  const fields = ["start", "end", "loc", "range", "comments"];
  let index2 = -1;
  while (++index2 < fields.length) {
    const field = fields[index2];
    if (field in from) {
      to[field] = from[field];
    }
  }
}

// node_modules/@mdx-js/mdx/lib/util/estree-util-specifiers-to-declarations.js
function specifiersToDeclarations(specifiers, init) {
  let index2 = -1;
  const declarations = [];
  const otherSpecifiers = [];
  let importNamespaceSpecifier;
  while (++index2 < specifiers.length) {
    const specifier = specifiers[index2];
    if (specifier.type === "ImportNamespaceSpecifier") {
      importNamespaceSpecifier = specifier;
    } else {
      otherSpecifiers.push(specifier);
    }
  }
  if (importNamespaceSpecifier) {
    const declarator = {
      type: "VariableDeclarator",
      id: importNamespaceSpecifier.local,
      init
    };
    create2(importNamespaceSpecifier, declarator);
    declarations.push(declarator);
  }
  declarations.push({
    type: "VariableDeclarator",
    id: {
      type: "ObjectPattern",
      properties: otherSpecifiers.map((specifier) => {
        let key2 = specifier.type === "ImportSpecifier" ? specifier.imported : specifier.type === "ExportSpecifier" ? specifier.exported : { type: "Identifier", name: "default" };
        let value2 = specifier.local;
        if (specifier.type === "ExportSpecifier") {
          value2 = key2;
          key2 = specifier.local;
        }
        const property = {
          type: "Property",
          kind: "init",
          shorthand: key2.name === value2.name,
          method: false,
          computed: false,
          key: key2,
          value: value2
        };
        create2(specifier, property);
        return property;
      })
    },
    init: importNamespaceSpecifier ? { type: "Identifier", name: importNamespaceSpecifier.local.name } : init
  });
  return declarations;
}

// node_modules/@mdx-js/mdx/lib/util/estree-util-to-id-or-member-expression.js
var toIdOrMemberExpression = toIdOrMemberExpressionFactory(
  "Identifier",
  "MemberExpression",
  name
);
var toJsxIdOrMemberExpression = (
  // @ts-expect-error: fine
  /** @type {(ids: Array<string | number>) => JSXIdentifier | JSXMemberExpression)} */
  toIdOrMemberExpressionFactory(
    "JSXIdentifier",
    "JSXMemberExpression",
    isJsxIdentifierName
  )
);
function toIdOrMemberExpressionFactory(idType, memberType, isIdentifier3) {
  return toIdOrMemberExpression2;
  function toIdOrMemberExpression2(ids) {
    let index2 = -1;
    let object;
    while (++index2 < ids.length) {
      const name2 = ids[index2];
      const valid2 = typeof name2 === "string" && isIdentifier3(name2);
      if (idType === "JSXIdentifier" && !valid2) {
        throw new Error("Cannot turn `" + name2 + "` into a JSX identifier");
      }
      const id = valid2 ? { type: idType, name: name2 } : { type: "Literal", value: name2 };
      object = object ? {
        type: memberType,
        object,
        property: id,
        computed: id.type === "Literal",
        optional: false
      } : id;
    }
    if (!object)
      throw new Error("Expected non-empty `ids` to be passed");
    if (object.type === "Literal")
      throw new Error("Expected identifier as left-most value");
    return object;
  }
}
function isJsxIdentifierName(name2) {
  let index2 = -1;
  while (++index2 < name2.length) {
    if (!(index2 ? jsxCont : start2)(name2.charCodeAt(index2)))
      return false;
  }
  return index2 > 0;
}
function jsxCont(code2) {
  return code2 === 45 || cont2(code2);
}

// node_modules/@mdx-js/mdx/lib/plugin/recma-jsx-build.js
function recmaJsxBuild(options) {
  const { development: development2, outputFormat } = options || {};
  return (tree, file) => {
    buildJsx(tree, { development: development2, filePath: file.history[0] });
    if (outputFormat === "function-body" && tree.body[0] && tree.body[0].type === "ImportDeclaration" && typeof tree.body[0].source.value === "string" && /\/jsx-(dev-)?runtime$/.test(tree.body[0].source.value)) {
      tree.body[0] = {
        type: "VariableDeclaration",
        kind: "const",
        declarations: specifiersToDeclarations(
          tree.body[0].specifiers,
          toIdOrMemberExpression(["arguments", 0])
        )
      };
    }
  };
}

// node_modules/is-reference/src/index.js
function is_reference(node2, parent) {
  if (node2.type === "MemberExpression") {
    return !node2.computed && is_reference(node2.object, node2);
  }
  if (node2.type === "Identifier") {
    if (!parent)
      return true;
    switch (parent.type) {
      case "MemberExpression":
        return parent.computed || node2 === parent.object;
      case "MethodDefinition":
        return parent.computed;
      case "PropertyDefinition":
        return parent.computed || node2 === parent.value;
      case "Property":
        return parent.computed || node2 === parent.value;
      case "ExportSpecifier":
      case "ImportSpecifier":
        return node2 === parent.local;
      case "LabeledStatement":
      case "BreakStatement":
      case "ContinueStatement":
        return false;
      default:
        return true;
    }
  }
  return false;
}

// node_modules/periscopic/src/index.js
function analyze(expression) {
  const map = /* @__PURE__ */ new WeakMap();
  const globals = /* @__PURE__ */ new Map();
  const scope = new Scope5(null, false);
  const references = [];
  let current_scope = scope;
  walk(expression, {
    enter(node2, parent) {
      switch (node2.type) {
        case "Identifier":
          if (parent && is_reference(node2, parent)) {
            references.push([current_scope, node2]);
          }
          break;
        case "ImportDeclaration":
          node2.specifiers.forEach((specifier) => {
            current_scope.declarations.set(specifier.local.name, specifier);
          });
          break;
        case "FunctionExpression":
        case "FunctionDeclaration":
        case "ArrowFunctionExpression":
          if (node2.type === "FunctionDeclaration") {
            if (node2.id) {
              current_scope.declarations.set(node2.id.name, node2);
            }
            map.set(node2, current_scope = new Scope5(current_scope, false));
          } else {
            map.set(node2, current_scope = new Scope5(current_scope, false));
            if (node2.type === "FunctionExpression" && node2.id) {
              current_scope.declarations.set(node2.id.name, node2);
            }
          }
          node2.params.forEach((param) => {
            extract_names(param).forEach((name2) => {
              current_scope.declarations.set(name2, node2);
            });
          });
          break;
        case "ForStatement":
        case "ForInStatement":
        case "ForOfStatement":
          map.set(node2, current_scope = new Scope5(current_scope, true));
          break;
        case "BlockStatement":
          map.set(node2, current_scope = new Scope5(current_scope, true));
          break;
        case "ClassDeclaration":
        case "VariableDeclaration":
          current_scope.add_declaration(node2);
          break;
        case "CatchClause":
          map.set(node2, current_scope = new Scope5(current_scope, true));
          if (node2.param) {
            extract_names(node2.param).forEach((name2) => {
              if (node2.param) {
                current_scope.declarations.set(name2, node2.param);
              }
            });
          }
          break;
      }
    },
    leave(node2) {
      if (map.has(node2) && current_scope !== null && current_scope.parent) {
        current_scope = current_scope.parent;
      }
    }
  });
  for (let i = references.length - 1; i >= 0; --i) {
    const [scope2, reference] = references[i];
    if (!scope2.references.has(reference.name)) {
      add_reference(scope2, reference.name);
    }
    if (!scope2.find_owner(reference.name)) {
      globals.set(reference.name, reference);
    }
  }
  return { map, scope, globals };
}
function add_reference(scope, name2) {
  scope.references.add(name2);
  if (scope.parent)
    add_reference(scope.parent, name2);
}
var Scope5 = class {
  /**
   * @param {Scope | null} parent 
   * @param {boolean} block 
   */
  constructor(parent, block) {
    this.parent = parent;
    this.block = block;
    this.declarations = /* @__PURE__ */ new Map();
    this.initialised_declarations = /* @__PURE__ */ new Set();
    this.references = /* @__PURE__ */ new Set();
  }
  /**
   * @param {import('estree').VariableDeclaration | import('estree').ClassDeclaration} node
   */
  add_declaration(node2) {
    if (node2.type === "VariableDeclaration") {
      if (node2.kind === "var" && this.block && this.parent) {
        this.parent.add_declaration(node2);
      } else {
        const handle_declarator = (declarator) => {
          extract_names(declarator.id).forEach((name2) => {
            this.declarations.set(name2, node2);
            if (declarator.init)
              this.initialised_declarations.add(name2);
          });
          ;
        };
        node2.declarations.forEach(handle_declarator);
      }
    } else if (node2.id) {
      this.declarations.set(node2.id.name, node2);
    }
  }
  /**
   * @param {string} name
   * @returns {Scope | null}
   */
  find_owner(name2) {
    if (this.declarations.has(name2))
      return this;
    return this.parent && this.parent.find_owner(name2);
  }
  /**
   * @param {string} name
   * @returns {boolean}
   */
  has(name2) {
    return this.declarations.has(name2) || !!this.parent && this.parent.has(name2);
  }
};
function extract_names(param) {
  return extract_identifiers(param).map((node2) => node2.name);
}
function extract_identifiers(param, nodes = []) {
  switch (param.type) {
    case "Identifier":
      nodes.push(param);
      break;
    case "MemberExpression":
      let object = param;
      while (object.type === "MemberExpression") {
        object = /** @type {any} */
        object.object;
      }
      nodes.push(
        /** @type {any} */
        object
      );
      break;
    case "ObjectPattern":
      const handle_prop = (prop) => {
        if (prop.type === "RestElement") {
          extract_identifiers(prop.argument, nodes);
        } else {
          extract_identifiers(prop.value, nodes);
        }
      };
      param.properties.forEach(handle_prop);
      break;
    case "ArrayPattern":
      const handle_element = (element2) => {
        if (element2)
          extract_identifiers(element2, nodes);
      };
      param.elements.forEach((element2) => {
        if (element2) {
          handle_element(element2);
        }
      });
      break;
    case "RestElement":
      extract_identifiers(param.argument, nodes);
      break;
    case "AssignmentPattern":
      extract_identifiers(param.left, nodes);
      break;
  }
  return nodes;
}

// node_modules/@mdx-js/mdx/lib/util/estree-util-declaration-to-expression.js
function declarationToExpression(declaration) {
  if (declaration.type === "FunctionDeclaration") {
    return { ...declaration, type: "FunctionExpression" };
  }
  if (declaration.type === "ClassDeclaration") {
    return { ...declaration, type: "ClassExpression" };
  }
  throw new Error("Cannot turn `" + declaration.type + "` into an expression");
}

// node_modules/@mdx-js/mdx/lib/util/estree-util-is-declaration.js
function isDeclaration(node2) {
  return Boolean(
    node2.type === "FunctionDeclaration" || node2.type === "ClassDeclaration" || node2.type === "VariableDeclaration"
  );
}

// node_modules/@mdx-js/mdx/lib/plugin/recma-document.js
function recmaDocument(options) {
  const options_ = options || {};
  const baseUrl = options_.baseUrl || void 0;
  const useDynamicImport = options_.useDynamicImport || void 0;
  const outputFormat = options_.outputFormat || "program";
  const pragma = options_.pragma === void 0 ? "React.createElement" : options_.pragma;
  const pragmaFrag = options_.pragmaFrag === void 0 ? "React.Fragment" : options_.pragmaFrag;
  const pragmaImportSource = options_.pragmaImportSource || "react";
  const jsxImportSource = options_.jsxImportSource || "react";
  const jsxRuntime = options_.jsxRuntime || "automatic";
  return (tree, file) => {
    const exportedIdentifiers = [];
    const replacement = [];
    const pragmas = [];
    let exportAllCount = 0;
    let layout;
    let content3;
    let child;
    if (!tree.comments)
      tree.comments = [];
    if (jsxRuntime) {
      pragmas.push("@jsxRuntime " + jsxRuntime);
    }
    if (jsxRuntime === "automatic" && jsxImportSource) {
      pragmas.push("@jsxImportSource " + jsxImportSource);
    }
    if (jsxRuntime === "classic" && pragma) {
      pragmas.push("@jsx " + pragma);
    }
    if (jsxRuntime === "classic" && pragmaFrag) {
      pragmas.push("@jsxFrag " + pragmaFrag);
    }
    if (pragmas.length > 0) {
      tree.comments.unshift({ type: "Block", value: pragmas.join(" ") });
    }
    if (jsxRuntime === "classic" && pragmaImportSource) {
      if (!pragma) {
        throw new Error(
          "Missing `pragma` in classic runtime with `pragmaImportSource`"
        );
      }
      handleEsm({
        type: "ImportDeclaration",
        specifiers: [
          {
            type: "ImportDefaultSpecifier",
            local: { type: "Identifier", name: pragma.split(".")[0] }
          }
        ],
        source: { type: "Literal", value: pragmaImportSource }
      });
    }
    for (child of tree.body) {
      if (child.type === "ExportDefaultDeclaration") {
        if (layout) {
          file.fail(
            "Cannot specify multiple layouts (previous: " + stringifyPosition(positionFromEstree(layout)) + ")",
            positionFromEstree(child),
            "recma-document:duplicate-layout"
          );
        }
        layout = child;
        replacement.push({
          type: "VariableDeclaration",
          kind: "const",
          declarations: [
            {
              type: "VariableDeclarator",
              id: { type: "Identifier", name: "MDXLayout" },
              init: isDeclaration(child.declaration) ? declarationToExpression(child.declaration) : child.declaration
            }
          ]
        });
      } else if (child.type === "ExportNamedDeclaration" && child.source) {
        const source2 = (
          /** @type {SimpleLiteral} */
          child.source
        );
        child.specifiers = child.specifiers.filter((specifier) => {
          if (specifier.exported.name === "default") {
            if (layout) {
              file.fail(
                "Cannot specify multiple layouts (previous: " + stringifyPosition(positionFromEstree(layout)) + ")",
                positionFromEstree(child),
                "recma-document:duplicate-layout"
              );
            }
            layout = specifier;
            const specifiers = [];
            if (specifier.local.name === "default") {
              specifiers.push({
                type: "ImportDefaultSpecifier",
                local: { type: "Identifier", name: "MDXLayout" }
              });
            } else {
              const importSpecifier = {
                type: "ImportSpecifier",
                imported: specifier.local,
                local: { type: "Identifier", name: "MDXLayout" }
              };
              create2(specifier.local, importSpecifier);
              specifiers.push(importSpecifier);
            }
            const from = { type: "Literal", value: source2.value };
            create2(source2, from);
            const declaration = {
              type: "ImportDeclaration",
              specifiers,
              source: from
            };
            create2(specifier, declaration);
            handleEsm(declaration);
            return false;
          }
          return true;
        });
        if (child.specifiers.length > 0) {
          handleExport(child);
        }
      } else if (child.type === "ExportNamedDeclaration" || child.type === "ExportAllDeclaration") {
        handleExport(child);
      } else if (child.type === "ImportDeclaration") {
        handleEsm(child);
      } else if (child.type === "ExpressionStatement" && // @ts-expect-error types are wrong: `JSXFragment` is an `Expression`.
      (child.expression.type === "JSXFragment" || child.expression.type === "JSXElement")) {
        content3 = true;
        replacement.push(...createMdxContent(child.expression, Boolean(layout)));
      } else {
        replacement.push(child);
      }
    }
    if (!content3) {
      replacement.push(...createMdxContent(void 0, Boolean(layout)));
    }
    exportedIdentifiers.push(["MDXContent", "default"]);
    if (outputFormat === "function-body") {
      replacement.push({
        type: "ReturnStatement",
        argument: {
          type: "ObjectExpression",
          properties: [
            ...Array.from({ length: exportAllCount }).map(
              /**
               * @param {undefined} _
               * @param {number} index
               * @returns {SpreadElement}
               */
              (_, index2) => ({
                type: "SpreadElement",
                argument: { type: "Identifier", name: "_exportAll" + (index2 + 1) }
              })
            ),
            ...exportedIdentifiers.map((d) => {
              const prop = {
                type: "Property",
                kind: "init",
                method: false,
                computed: false,
                shorthand: typeof d === "string",
                key: {
                  type: "Identifier",
                  name: typeof d === "string" ? d : d[1]
                },
                value: {
                  type: "Identifier",
                  name: typeof d === "string" ? d : d[0]
                }
              };
              return prop;
            })
          ]
        }
      });
    } else {
      replacement.push({
        type: "ExportDefaultDeclaration",
        declaration: { type: "Identifier", name: "MDXContent" }
      });
    }
    tree.body = replacement;
    if (baseUrl) {
      walk(tree, {
        enter(node2) {
          if (node2.type === "MemberExpression" && "object" in node2 && node2.object.type === "MetaProperty" && node2.property.type === "Identifier" && node2.object.meta.name === "import" && node2.object.property.name === "meta" && node2.property.name === "url") {
            const replacement2 = { type: "Literal", value: baseUrl };
            this.replace(replacement2);
          }
        }
      });
    }
    function handleExport(node2) {
      if (node2.type === "ExportNamedDeclaration") {
        if (node2.declaration) {
          exportedIdentifiers.push(
            ...analyze(node2.declaration).scope.declarations.keys()
          );
        }
        for (child of node2.specifiers) {
          exportedIdentifiers.push(child.exported.name);
        }
      }
      handleEsm(node2);
    }
    function handleEsm(node2) {
      if (baseUrl && node2.source) {
        let value2 = String(node2.source.value);
        try {
          value2 = String(new URL(value2));
        } catch {
          if (/^\.{0,2}\//.test(value2)) {
            value2 = String(new URL(value2, baseUrl));
          }
        }
        const literal4 = { type: "Literal", value: value2 };
        create2(node2.source, literal4);
        node2.source = literal4;
      }
      let replace;
      let init;
      if (outputFormat === "function-body") {
        if (
          // Always have a source:
          node2.type === "ImportDeclaration" || node2.type === "ExportAllDeclaration" || // Source optional:
          node2.type === "ExportNamedDeclaration" && node2.source
        ) {
          if (!useDynamicImport) {
            file.fail(
              "Cannot use `import` or `export \u2026 from` in `evaluate` (outputting a function body) by default: please set `useDynamicImport: true` (and probably specify a `baseUrl`)",
              positionFromEstree(node2),
              "recma-document:invalid-esm-statement"
            );
          }
          if (!node2.source) {
            throw new Error("Expected `node.source` to be defined");
          }
          const argument = { type: "ImportExpression", source: node2.source };
          create2(node2, argument);
          init = { type: "AwaitExpression", argument };
          if ((node2.type === "ImportDeclaration" || node2.type === "ExportNamedDeclaration") && node2.specifiers.length === 0) {
            replace = { type: "ExpressionStatement", expression: init };
          } else {
            replace = {
              type: "VariableDeclaration",
              kind: "const",
              declarations: node2.type === "ExportAllDeclaration" ? [
                {
                  type: "VariableDeclarator",
                  id: {
                    type: "Identifier",
                    name: "_exportAll" + ++exportAllCount
                  },
                  init
                }
              ] : specifiersToDeclarations(node2.specifiers, init)
            };
          }
        } else if (node2.declaration) {
          replace = node2.declaration;
        } else {
          const declarators = node2.specifiers.filter(
            (specifier) => specifier.local.name !== specifier.exported.name
          ).map((specifier) => ({
            type: "VariableDeclarator",
            id: specifier.exported,
            init: specifier.local
          }));
          if (declarators.length > 0) {
            replace = {
              type: "VariableDeclaration",
              kind: "const",
              declarations: declarators
            };
          }
        }
      } else {
        replace = node2;
      }
      if (replace) {
        replacement.push(replace);
      }
    }
  };
  function createMdxContent(content3, hasInternalLayout) {
    const element2 = {
      type: "JSXElement",
      openingElement: {
        type: "JSXOpeningElement",
        name: { type: "JSXIdentifier", name: "MDXLayout" },
        attributes: [
          {
            type: "JSXSpreadAttribute",
            argument: { type: "Identifier", name: "props" }
          }
        ],
        selfClosing: false
      },
      closingElement: {
        type: "JSXClosingElement",
        name: { type: "JSXIdentifier", name: "MDXLayout" }
      },
      children: [
        {
          type: "JSXElement",
          openingElement: {
            type: "JSXOpeningElement",
            name: { type: "JSXIdentifier", name: "_createMdxContent" },
            attributes: [
              {
                type: "JSXSpreadAttribute",
                argument: { type: "Identifier", name: "props" }
              }
            ],
            selfClosing: true
          },
          closingElement: null,
          children: []
        }
      ]
    };
    let result = (
      /** @type {Expression} */
      element2
    );
    if (!hasInternalLayout) {
      result = {
        type: "ConditionalExpression",
        test: { type: "Identifier", name: "MDXLayout" },
        consequent: result,
        alternate: {
          type: "CallExpression",
          callee: { type: "Identifier", name: "_createMdxContent" },
          arguments: [{ type: "Identifier", name: "props" }],
          optional: false
        }
      };
    }
    let argument = content3 || { type: "Literal", value: null };
    if (argument && // @ts-expect-error: fine.
    argument.type === "JSXFragment" && // @ts-expect-error: fine.
    argument.children.length === 1 && // @ts-expect-error: fine.
    argument.children[0].type === "JSXElement") {
      argument = argument.children[0];
    }
    return [
      {
        type: "FunctionDeclaration",
        id: { type: "Identifier", name: "_createMdxContent" },
        params: [{ type: "Identifier", name: "props" }],
        body: {
          type: "BlockStatement",
          body: [{ type: "ReturnStatement", argument }]
        }
      },
      {
        type: "FunctionDeclaration",
        id: { type: "Identifier", name: "MDXContent" },
        params: [
          {
            type: "AssignmentPattern",
            left: { type: "Identifier", name: "props" },
            right: { type: "ObjectExpression", properties: [] }
          }
        ],
        body: {
          type: "BlockStatement",
          body: [{ type: "ReturnStatement", argument: result }]
        }
      }
    ];
  }
}

// node_modules/@mdx-js/mdx/lib/util/estree-util-to-binary-addition.js
function toBinaryAddition(expressions) {
  let index2 = -1;
  let left;
  while (++index2 < expressions.length) {
    const right = expressions[index2];
    left = left ? { type: "BinaryExpression", left, operator: "+", right } : right;
  }
  if (!left)
    throw new Error("Expected non-empty `expressions` to be passed");
  return left;
}

// node_modules/@mdx-js/mdx/lib/plugin/recma-jsx-rewrite.js
var own7 = {}.hasOwnProperty;
function recmaJsxRewrite(options) {
  const { development: development2, providerImportSource, outputFormat } = options || {};
  return (tree, file) => {
    const scopeInfo = analyze(tree);
    const fnStack = [];
    let importProvider = false;
    let createErrorHelper = false;
    let currentScope;
    walk(tree, {
      enter(node2) {
        const newScope = (
          /** @type {Scope | undefined} */
          scopeInfo.map.get(node2)
        );
        if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
          fnStack.push({
            objects: [],
            components: [],
            tags: [],
            references: {},
            idToInvalidComponentName: /* @__PURE__ */ new Map(),
            node: node2
          });
          if (isNamedFunction(node2, "MDXContent") && newScope && !inScope(newScope, "MDXLayout")) {
            fnStack[0].components.push("MDXLayout");
          }
        }
        const fnScope = fnStack[0];
        if (!fnScope || !isNamedFunction(fnScope.node, "_createMdxContent") && !providerImportSource) {
          return;
        }
        if (newScope) {
          newScope.node = node2;
          currentScope = newScope;
        }
        if (currentScope && node2.type === "JSXElement") {
          let name2 = node2.openingElement.name;
          if (name2.type === "JSXMemberExpression") {
            const ids = [];
            while (name2.type === "JSXMemberExpression") {
              ids.unshift(name2.property.name);
              name2 = name2.object;
            }
            ids.unshift(name2.name);
            const fullId = ids.join(".");
            const id = name2.name;
            const isInScope = inScope(currentScope, id);
            if (!own7.call(fnScope.references, fullId)) {
              const parentScope = (
                /** @type {Scope | undefined} */
                currentScope.parent
              );
              if (!isInScope || // If the parent scope is `_createMdxContent`, then this
              // references a component we can add a check statement for.
              parentScope && parentScope.node.type === "FunctionDeclaration" && isNamedFunction(parentScope.node, "_createMdxContent")) {
                fnScope.references[fullId] = { node: node2, component: true };
              }
            }
            if (!fnScope.objects.includes(id) && !isInScope) {
              fnScope.objects.push(id);
            }
          } else if (name2.type === "JSXNamespacedName") {
          } else if (name(name2.name) && !/^[a-z]/.test(name2.name)) {
            const id = name2.name;
            if (!inScope(currentScope, id)) {
              if (id !== "MDXLayout" && !own7.call(fnScope.references, id)) {
                fnScope.references[id] = { node: node2, component: true };
              }
              if (!fnScope.components.includes(id)) {
                fnScope.components.push(id);
              }
            }
          } else if (node2.data && node2.data._mdxExplicitJsx) {
          } else {
            const id = name2.name;
            if (!fnScope.tags.includes(id)) {
              fnScope.tags.push(id);
            }
            let jsxIdExpression = ["_components", id];
            if (name(id) === false) {
              let invalidComponentName = fnScope.idToInvalidComponentName.get(id);
              if (invalidComponentName === void 0) {
                invalidComponentName = `_component${fnScope.idToInvalidComponentName.size}`;
                fnScope.idToInvalidComponentName.set(id, invalidComponentName);
              }
              jsxIdExpression = [invalidComponentName];
            }
            node2.openingElement.name = toJsxIdOrMemberExpression(jsxIdExpression);
            if (node2.closingElement) {
              node2.closingElement.name = toJsxIdOrMemberExpression(jsxIdExpression);
            }
          }
        }
      },
      leave(node2) {
        const defaults = [];
        const actual = [];
        const parameters = [];
        const declarations = [];
        if (currentScope && currentScope.node === node2) {
          currentScope = currentScope.parent;
        }
        if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
          const fn = node2;
          const scope = fnStack[fnStack.length - 1];
          let name2;
          for (name2 of scope.tags) {
            defaults.push({
              type: "Property",
              kind: "init",
              key: name(name2) ? { type: "Identifier", name: name2 } : { type: "Literal", value: name2 },
              value: { type: "Literal", value: name2 },
              method: false,
              shorthand: false,
              computed: false
            });
          }
          actual.push(...scope.components);
          for (name2 of scope.objects) {
            if (!actual.includes(name2)) {
              actual.push(name2);
            }
          }
          const statements = [];
          if (defaults.length > 0 || actual.length > 0 || scope.idToInvalidComponentName.size > 0) {
            if (providerImportSource) {
              importProvider = true;
              parameters.push({
                type: "CallExpression",
                callee: { type: "Identifier", name: "_provideComponents" },
                arguments: [],
                optional: false
              });
            }
            if (isNamedFunction(scope.node, "MDXContent") || isNamedFunction(scope.node, "_createMdxContent")) {
              parameters.push(toIdOrMemberExpression(["props", "components"]));
            }
            if (defaults.length > 0 || parameters.length > 1) {
              parameters.unshift({
                type: "ObjectExpression",
                properties: defaults
              });
            }
            let componentsInit = parameters.length > 1 ? {
              type: "CallExpression",
              callee: toIdOrMemberExpression(["Object", "assign"]),
              arguments: parameters,
              optional: false
            } : parameters[0].type === "MemberExpression" ? (
              // If we’re only getting components from `props.components`,
              // make sure it’s defined.
              {
                type: "LogicalExpression",
                operator: "||",
                left: parameters[0],
                right: { type: "ObjectExpression", properties: [] }
              }
            ) : parameters[0];
            let componentsPattern;
            if (actual.length > 0) {
              componentsPattern = {
                type: "ObjectPattern",
                properties: actual.map((name3) => ({
                  type: "Property",
                  kind: "init",
                  key: {
                    type: "Identifier",
                    name: name3 === "MDXLayout" ? "wrapper" : name3
                  },
                  value: { type: "Identifier", name: name3 },
                  method: false,
                  shorthand: name3 !== "MDXLayout",
                  computed: false
                }))
              };
            }
            if (scope.tags.length > 0) {
              declarations.push({
                type: "VariableDeclarator",
                id: { type: "Identifier", name: "_components" },
                init: componentsInit
              });
              componentsInit = { type: "Identifier", name: "_components" };
            }
            if (isNamedFunction(scope.node, "_createMdxContent")) {
              for (const [
                id,
                componentName
              ] of scope.idToInvalidComponentName) {
                declarations.push({
                  type: "VariableDeclarator",
                  id: { type: "Identifier", name: componentName },
                  init: {
                    type: "MemberExpression",
                    object: { type: "Identifier", name: "_components" },
                    property: { type: "Literal", value: id },
                    computed: true,
                    optional: false
                  }
                });
              }
            }
            if (componentsPattern) {
              declarations.push({
                type: "VariableDeclarator",
                id: componentsPattern,
                init: componentsInit
              });
            }
            if (declarations.length > 0) {
              statements.push({
                type: "VariableDeclaration",
                kind: "const",
                declarations
              });
            }
          }
          let key2;
          for (key2 in scope.references) {
            if (own7.call(scope.references, key2)) {
              const parts = key2.split(".");
              let index3 = 0;
              while (++index3 < parts.length) {
                const partial = parts.slice(0, index3).join(".");
                if (!own7.call(scope.references, partial)) {
                  scope.references[partial] = {
                    node: scope.references[key2].node,
                    component: false
                  };
                }
              }
            }
          }
          const references = Object.keys(scope.references).sort();
          let index2 = -1;
          while (++index2 < references.length) {
            const id = references[index2];
            const info = scope.references[id];
            const place = stringifyPosition(positionFromEstree(info.node));
            const parameters2 = [
              { type: "Literal", value: id },
              { type: "Literal", value: info.component }
            ];
            createErrorHelper = true;
            if (development2 && place !== "1:1-1:1") {
              parameters2.push({ type: "Literal", value: place });
            }
            statements.push({
              type: "IfStatement",
              test: {
                type: "UnaryExpression",
                operator: "!",
                prefix: true,
                argument: toIdOrMemberExpression(id.split("."))
              },
              consequent: {
                type: "ExpressionStatement",
                expression: {
                  type: "CallExpression",
                  callee: { type: "Identifier", name: "_missingMdxReference" },
                  arguments: parameters2,
                  optional: false
                }
              },
              alternate: null
            });
          }
          if (statements.length > 0) {
            if (fn.body.type !== "BlockStatement") {
              fn.body = {
                type: "BlockStatement",
                body: [{ type: "ReturnStatement", argument: fn.body }]
              };
            }
            fn.body.body.unshift(...statements);
          }
          fnStack.pop();
        }
      }
    });
    if (importProvider && providerImportSource) {
      tree.body.unshift(
        createImportProvider(providerImportSource, outputFormat)
      );
    }
    if (createErrorHelper) {
      const message = [
        { type: "Literal", value: "Expected " },
        {
          type: "ConditionalExpression",
          test: { type: "Identifier", name: "component" },
          consequent: { type: "Literal", value: "component" },
          alternate: { type: "Literal", value: "object" }
        },
        { type: "Literal", value: " `" },
        { type: "Identifier", name: "id" },
        {
          type: "Literal",
          value: "` to be defined: you likely forgot to import, pass, or provide it."
        }
      ];
      const parameters = [
        { type: "Identifier", name: "id" },
        { type: "Identifier", name: "component" }
      ];
      if (development2) {
        message.push({
          type: "ConditionalExpression",
          test: { type: "Identifier", name: "place" },
          consequent: toBinaryAddition([
            { type: "Literal", value: "\nIt\u2019s referenced in your code at `" },
            { type: "Identifier", name: "place" },
            {
              type: "Literal",
              value: (file.path ? "` in `" + file.path : "") + "`"
            }
          ]),
          alternate: { type: "Literal", value: "" }
        });
        parameters.push({ type: "Identifier", name: "place" });
      }
      tree.body.push({
        type: "FunctionDeclaration",
        id: { type: "Identifier", name: "_missingMdxReference" },
        generator: false,
        async: false,
        params: parameters,
        body: {
          type: "BlockStatement",
          body: [
            {
              type: "ThrowStatement",
              argument: {
                type: "NewExpression",
                callee: { type: "Identifier", name: "Error" },
                arguments: [toBinaryAddition(message)]
              }
            }
          ]
        }
      });
    }
  };
}
function createImportProvider(providerImportSource, outputFormat) {
  const specifiers = [
    {
      type: "ImportSpecifier",
      imported: { type: "Identifier", name: "useMDXComponents" },
      local: { type: "Identifier", name: "_provideComponents" }
    }
  ];
  return outputFormat === "function-body" ? {
    type: "VariableDeclaration",
    kind: "const",
    declarations: specifiersToDeclarations(
      specifiers,
      toIdOrMemberExpression(["arguments", 0])
    )
  } : {
    type: "ImportDeclaration",
    specifiers,
    source: { type: "Literal", value: providerImportSource }
  };
}
function isNamedFunction(node2, name2) {
  return Boolean(node2 && "id" in node2 && node2.id && node2.id.name === name2);
}
function inScope(scope, id) {
  let currentScope = scope;
  while (currentScope) {
    if (currentScope.declarations.has(id)) {
      return true;
    }
    currentScope = currentScope.parent;
  }
  return false;
}

// node_modules/astring/dist/astring.mjs
var { stringify } = JSON;
if (!String.prototype.repeat) {
  throw new Error(
    "String.prototype.repeat is undefined, see https://github.com/davidbonnet/astring#installation"
  );
}
if (!String.prototype.endsWith) {
  throw new Error(
    "String.prototype.endsWith is undefined, see https://github.com/davidbonnet/astring#installation"
  );
}
var OPERATOR_PRECEDENCE = {
  "||": 3,
  "&&": 4,
  "|": 5,
  "??": 5,
  "^": 6,
  "&": 7,
  "==": 8,
  "!=": 8,
  "===": 8,
  "!==": 8,
  "<": 9,
  ">": 9,
  "<=": 9,
  ">=": 9,
  in: 9,
  instanceof: 9,
  "<<": 10,
  ">>": 10,
  ">>>": 10,
  "+": 11,
  "-": 11,
  "*": 12,
  "%": 12,
  "/": 12,
  "**": 13
};
var NEEDS_PARENTHESES = 17;
var EXPRESSIONS_PRECEDENCE = {
  // Definitions
  ArrayExpression: 20,
  TaggedTemplateExpression: 20,
  ThisExpression: 20,
  Identifier: 20,
  PrivateIdentifier: 20,
  Literal: 18,
  TemplateLiteral: 20,
  Super: 20,
  SequenceExpression: 20,
  // Operations
  MemberExpression: 19,
  ChainExpression: 19,
  CallExpression: 19,
  NewExpression: 19,
  // Other definitions
  ArrowFunctionExpression: NEEDS_PARENTHESES,
  ClassExpression: NEEDS_PARENTHESES,
  FunctionExpression: NEEDS_PARENTHESES,
  ObjectExpression: NEEDS_PARENTHESES,
  // Other operations
  UpdateExpression: 16,
  UnaryExpression: 15,
  AwaitExpression: 15,
  BinaryExpression: 14,
  LogicalExpression: 13,
  ConditionalExpression: 4,
  AssignmentExpression: 3,
  YieldExpression: 2,
  RestElement: 1
};
function formatSequence(state, nodes) {
  const { generator } = state;
  state.write("(");
  if (nodes != null && nodes.length > 0) {
    generator[nodes[0].type](nodes[0], state);
    const { length } = nodes;
    for (let i = 1; i < length; i++) {
      const param = nodes[i];
      state.write(", ");
      generator[param.type](param, state);
    }
  }
  state.write(")");
}
function expressionNeedsParenthesis(state, node2, parentNode, isRightHand) {
  const nodePrecedence = state.expressionsPrecedence[node2.type];
  if (nodePrecedence === NEEDS_PARENTHESES) {
    return true;
  }
  const parentNodePrecedence = state.expressionsPrecedence[parentNode.type];
  if (nodePrecedence !== parentNodePrecedence) {
    return !isRightHand && nodePrecedence === 15 && parentNodePrecedence === 14 && parentNode.operator === "**" || nodePrecedence < parentNodePrecedence;
  }
  if (nodePrecedence !== 13 && nodePrecedence !== 14) {
    return false;
  }
  if (node2.operator === "**" && parentNode.operator === "**") {
    return !isRightHand;
  }
  if (isRightHand) {
    return OPERATOR_PRECEDENCE[node2.operator] <= OPERATOR_PRECEDENCE[parentNode.operator];
  }
  return OPERATOR_PRECEDENCE[node2.operator] < OPERATOR_PRECEDENCE[parentNode.operator];
}
function formatExpression(state, node2, parentNode, isRightHand) {
  const { generator } = state;
  if (expressionNeedsParenthesis(state, node2, parentNode, isRightHand)) {
    state.write("(");
    generator[node2.type](node2, state);
    state.write(")");
  } else {
    generator[node2.type](node2, state);
  }
}
function reindent(state, text5, indent, lineEnd) {
  const lines = text5.split("\n");
  const end = lines.length - 1;
  state.write(lines[0].trim());
  if (end > 0) {
    state.write(lineEnd);
    for (let i = 1; i < end; i++) {
      state.write(indent + lines[i].trim() + lineEnd);
    }
    state.write(indent + lines[end].trim());
  }
}
function formatComments(state, comments, indent, lineEnd) {
  const { length } = comments;
  for (let i = 0; i < length; i++) {
    const comment2 = comments[i];
    state.write(indent);
    if (comment2.type[0] === "L") {
      state.write("// " + comment2.value.trim() + "\n", comment2);
    } else {
      state.write("/*");
      reindent(state, comment2.value, indent, lineEnd);
      state.write("*/" + lineEnd);
    }
  }
}
function hasCallExpression(node2) {
  let currentNode = node2;
  while (currentNode != null) {
    const { type } = currentNode;
    if (type[0] === "C" && type[1] === "a") {
      return true;
    } else if (type[0] === "M" && type[1] === "e" && type[2] === "m") {
      currentNode = currentNode.object;
    } else {
      return false;
    }
  }
}
function formatVariableDeclaration(state, node2) {
  const { generator } = state;
  const { declarations } = node2;
  state.write(node2.kind + " ");
  const { length } = declarations;
  if (length > 0) {
    generator.VariableDeclarator(declarations[0], state);
    for (let i = 1; i < length; i++) {
      state.write(", ");
      generator.VariableDeclarator(declarations[i], state);
    }
  }
}
var ForInStatement;
var FunctionDeclaration;
var RestElement;
var BinaryExpression;
var ArrayExpression;
var BlockStatement;
var GENERATOR = {
  /*
  Default generator.
  */
  Program(node2, state) {
    const indent = state.indent.repeat(state.indentLevel);
    const { lineEnd, writeComments } = state;
    if (writeComments && node2.comments != null) {
      formatComments(state, node2.comments, indent, lineEnd);
    }
    const statements = node2.body;
    const { length } = statements;
    for (let i = 0; i < length; i++) {
      const statement = statements[i];
      if (writeComments && statement.comments != null) {
        formatComments(state, statement.comments, indent, lineEnd);
      }
      state.write(indent);
      this[statement.type](statement, state);
      state.write(lineEnd);
    }
    if (writeComments && node2.trailingComments != null) {
      formatComments(state, node2.trailingComments, indent, lineEnd);
    }
  },
  BlockStatement: BlockStatement = function(node2, state) {
    const indent = state.indent.repeat(state.indentLevel++);
    const { lineEnd, writeComments } = state;
    const statementIndent = indent + state.indent;
    state.write("{");
    const statements = node2.body;
    if (statements != null && statements.length > 0) {
      state.write(lineEnd);
      if (writeComments && node2.comments != null) {
        formatComments(state, node2.comments, statementIndent, lineEnd);
      }
      const { length } = statements;
      for (let i = 0; i < length; i++) {
        const statement = statements[i];
        if (writeComments && statement.comments != null) {
          formatComments(state, statement.comments, statementIndent, lineEnd);
        }
        state.write(statementIndent);
        this[statement.type](statement, state);
        state.write(lineEnd);
      }
      state.write(indent);
    } else {
      if (writeComments && node2.comments != null) {
        state.write(lineEnd);
        formatComments(state, node2.comments, statementIndent, lineEnd);
        state.write(indent);
      }
    }
    if (writeComments && node2.trailingComments != null) {
      formatComments(state, node2.trailingComments, statementIndent, lineEnd);
    }
    state.write("}");
    state.indentLevel--;
  },
  ClassBody: BlockStatement,
  StaticBlock(node2, state) {
    state.write("static ");
    this.BlockStatement(node2, state);
  },
  EmptyStatement(node2, state) {
    state.write(";");
  },
  ExpressionStatement(node2, state) {
    const precedence = state.expressionsPrecedence[node2.expression.type];
    if (precedence === NEEDS_PARENTHESES || precedence === 3 && node2.expression.left.type[0] === "O") {
      state.write("(");
      this[node2.expression.type](node2.expression, state);
      state.write(")");
    } else {
      this[node2.expression.type](node2.expression, state);
    }
    state.write(";");
  },
  IfStatement(node2, state) {
    state.write("if (");
    this[node2.test.type](node2.test, state);
    state.write(") ");
    this[node2.consequent.type](node2.consequent, state);
    if (node2.alternate != null) {
      state.write(" else ");
      this[node2.alternate.type](node2.alternate, state);
    }
  },
  LabeledStatement(node2, state) {
    this[node2.label.type](node2.label, state);
    state.write(": ");
    this[node2.body.type](node2.body, state);
  },
  BreakStatement(node2, state) {
    state.write("break");
    if (node2.label != null) {
      state.write(" ");
      this[node2.label.type](node2.label, state);
    }
    state.write(";");
  },
  ContinueStatement(node2, state) {
    state.write("continue");
    if (node2.label != null) {
      state.write(" ");
      this[node2.label.type](node2.label, state);
    }
    state.write(";");
  },
  WithStatement(node2, state) {
    state.write("with (");
    this[node2.object.type](node2.object, state);
    state.write(") ");
    this[node2.body.type](node2.body, state);
  },
  SwitchStatement(node2, state) {
    const indent = state.indent.repeat(state.indentLevel++);
    const { lineEnd, writeComments } = state;
    state.indentLevel++;
    const caseIndent = indent + state.indent;
    const statementIndent = caseIndent + state.indent;
    state.write("switch (");
    this[node2.discriminant.type](node2.discriminant, state);
    state.write(") {" + lineEnd);
    const { cases: occurences } = node2;
    const { length: occurencesCount } = occurences;
    for (let i = 0; i < occurencesCount; i++) {
      const occurence = occurences[i];
      if (writeComments && occurence.comments != null) {
        formatComments(state, occurence.comments, caseIndent, lineEnd);
      }
      if (occurence.test) {
        state.write(caseIndent + "case ");
        this[occurence.test.type](occurence.test, state);
        state.write(":" + lineEnd);
      } else {
        state.write(caseIndent + "default:" + lineEnd);
      }
      const { consequent } = occurence;
      const { length: consequentCount } = consequent;
      for (let i2 = 0; i2 < consequentCount; i2++) {
        const statement = consequent[i2];
        if (writeComments && statement.comments != null) {
          formatComments(state, statement.comments, statementIndent, lineEnd);
        }
        state.write(statementIndent);
        this[statement.type](statement, state);
        state.write(lineEnd);
      }
    }
    state.indentLevel -= 2;
    state.write(indent + "}");
  },
  ReturnStatement(node2, state) {
    state.write("return");
    if (node2.argument) {
      state.write(" ");
      this[node2.argument.type](node2.argument, state);
    }
    state.write(";");
  },
  ThrowStatement(node2, state) {
    state.write("throw ");
    this[node2.argument.type](node2.argument, state);
    state.write(";");
  },
  TryStatement(node2, state) {
    state.write("try ");
    this[node2.block.type](node2.block, state);
    if (node2.handler) {
      const { handler } = node2;
      if (handler.param == null) {
        state.write(" catch ");
      } else {
        state.write(" catch (");
        this[handler.param.type](handler.param, state);
        state.write(") ");
      }
      this[handler.body.type](handler.body, state);
    }
    if (node2.finalizer) {
      state.write(" finally ");
      this[node2.finalizer.type](node2.finalizer, state);
    }
  },
  WhileStatement(node2, state) {
    state.write("while (");
    this[node2.test.type](node2.test, state);
    state.write(") ");
    this[node2.body.type](node2.body, state);
  },
  DoWhileStatement(node2, state) {
    state.write("do ");
    this[node2.body.type](node2.body, state);
    state.write(" while (");
    this[node2.test.type](node2.test, state);
    state.write(");");
  },
  ForStatement(node2, state) {
    state.write("for (");
    if (node2.init != null) {
      const { init } = node2;
      if (init.type[0] === "V") {
        formatVariableDeclaration(state, init);
      } else {
        this[init.type](init, state);
      }
    }
    state.write("; ");
    if (node2.test) {
      this[node2.test.type](node2.test, state);
    }
    state.write("; ");
    if (node2.update) {
      this[node2.update.type](node2.update, state);
    }
    state.write(") ");
    this[node2.body.type](node2.body, state);
  },
  ForInStatement: ForInStatement = function(node2, state) {
    state.write(`for ${node2.await ? "await " : ""}(`);
    const { left } = node2;
    if (left.type[0] === "V") {
      formatVariableDeclaration(state, left);
    } else {
      this[left.type](left, state);
    }
    state.write(node2.type[3] === "I" ? " in " : " of ");
    this[node2.right.type](node2.right, state);
    state.write(") ");
    this[node2.body.type](node2.body, state);
  },
  ForOfStatement: ForInStatement,
  DebuggerStatement(node2, state) {
    state.write("debugger;", node2);
  },
  FunctionDeclaration: FunctionDeclaration = function(node2, state) {
    state.write(
      (node2.async ? "async " : "") + (node2.generator ? "function* " : "function ") + (node2.id ? node2.id.name : ""),
      node2
    );
    formatSequence(state, node2.params);
    state.write(" ");
    this[node2.body.type](node2.body, state);
  },
  FunctionExpression: FunctionDeclaration,
  VariableDeclaration(node2, state) {
    formatVariableDeclaration(state, node2);
    state.write(";");
  },
  VariableDeclarator(node2, state) {
    this[node2.id.type](node2.id, state);
    if (node2.init != null) {
      state.write(" = ");
      this[node2.init.type](node2.init, state);
    }
  },
  ClassDeclaration(node2, state) {
    state.write("class " + (node2.id ? `${node2.id.name} ` : ""), node2);
    if (node2.superClass) {
      state.write("extends ");
      const { superClass } = node2;
      const { type } = superClass;
      const precedence = state.expressionsPrecedence[type];
      if ((type[0] !== "C" || type[1] !== "l" || type[5] !== "E") && (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.ClassExpression)) {
        state.write("(");
        this[node2.superClass.type](superClass, state);
        state.write(")");
      } else {
        this[superClass.type](superClass, state);
      }
      state.write(" ");
    }
    this.ClassBody(node2.body, state);
  },
  ImportDeclaration(node2, state) {
    state.write("import ");
    const { specifiers } = node2;
    const { length } = specifiers;
    let i = 0;
    if (length > 0) {
      for (; i < length; ) {
        if (i > 0) {
          state.write(", ");
        }
        const specifier = specifiers[i];
        const type = specifier.type[6];
        if (type === "D") {
          state.write(specifier.local.name, specifier);
          i++;
        } else if (type === "N") {
          state.write("* as " + specifier.local.name, specifier);
          i++;
        } else {
          break;
        }
      }
      if (i < length) {
        state.write("{");
        for (; ; ) {
          const specifier = specifiers[i];
          const { name: name2 } = specifier.imported;
          state.write(name2, specifier);
          if (name2 !== specifier.local.name) {
            state.write(" as " + specifier.local.name);
          }
          if (++i < length) {
            state.write(", ");
          } else {
            break;
          }
        }
        state.write("}");
      }
      state.write(" from ");
    }
    this.Literal(node2.source, state);
    state.write(";");
  },
  ImportExpression(node2, state) {
    state.write("import(");
    this[node2.source.type](node2.source, state);
    state.write(")");
  },
  ExportDefaultDeclaration(node2, state) {
    state.write("export default ");
    this[node2.declaration.type](node2.declaration, state);
    if (state.expressionsPrecedence[node2.declaration.type] != null && node2.declaration.type[0] !== "F") {
      state.write(";");
    }
  },
  ExportNamedDeclaration(node2, state) {
    state.write("export ");
    if (node2.declaration) {
      this[node2.declaration.type](node2.declaration, state);
    } else {
      state.write("{");
      const { specifiers } = node2, { length } = specifiers;
      if (length > 0) {
        for (let i = 0; ; ) {
          const specifier = specifiers[i];
          const { name: name2 } = specifier.local;
          state.write(name2, specifier);
          if (name2 !== specifier.exported.name) {
            state.write(" as " + specifier.exported.name);
          }
          if (++i < length) {
            state.write(", ");
          } else {
            break;
          }
        }
      }
      state.write("}");
      if (node2.source) {
        state.write(" from ");
        this.Literal(node2.source, state);
      }
      state.write(";");
    }
  },
  ExportAllDeclaration(node2, state) {
    if (node2.exported != null) {
      state.write("export * as " + node2.exported.name + " from ");
    } else {
      state.write("export * from ");
    }
    this.Literal(node2.source, state);
    state.write(";");
  },
  MethodDefinition(node2, state) {
    if (node2.static) {
      state.write("static ");
    }
    const kind = node2.kind[0];
    if (kind === "g" || kind === "s") {
      state.write(node2.kind + " ");
    }
    if (node2.value.async) {
      state.write("async ");
    }
    if (node2.value.generator) {
      state.write("*");
    }
    if (node2.computed) {
      state.write("[");
      this[node2.key.type](node2.key, state);
      state.write("]");
    } else {
      this[node2.key.type](node2.key, state);
    }
    formatSequence(state, node2.value.params);
    state.write(" ");
    this[node2.value.body.type](node2.value.body, state);
  },
  ClassExpression(node2, state) {
    this.ClassDeclaration(node2, state);
  },
  ArrowFunctionExpression(node2, state) {
    state.write(node2.async ? "async " : "", node2);
    const { params } = node2;
    if (params != null) {
      if (params.length === 1 && params[0].type[0] === "I") {
        state.write(params[0].name, params[0]);
      } else {
        formatSequence(state, node2.params);
      }
    }
    state.write(" => ");
    if (node2.body.type[0] === "O") {
      state.write("(");
      this.ObjectExpression(node2.body, state);
      state.write(")");
    } else {
      this[node2.body.type](node2.body, state);
    }
  },
  ThisExpression(node2, state) {
    state.write("this", node2);
  },
  Super(node2, state) {
    state.write("super", node2);
  },
  RestElement: RestElement = function(node2, state) {
    state.write("...");
    this[node2.argument.type](node2.argument, state);
  },
  SpreadElement: RestElement,
  YieldExpression(node2, state) {
    state.write(node2.delegate ? "yield*" : "yield");
    if (node2.argument) {
      state.write(" ");
      this[node2.argument.type](node2.argument, state);
    }
  },
  AwaitExpression(node2, state) {
    state.write("await ", node2);
    formatExpression(state, node2.argument, node2);
  },
  TemplateLiteral(node2, state) {
    const { quasis, expressions } = node2;
    state.write("`");
    const { length } = expressions;
    for (let i = 0; i < length; i++) {
      const expression = expressions[i];
      const quasi2 = quasis[i];
      state.write(quasi2.value.raw, quasi2);
      state.write("${");
      this[expression.type](expression, state);
      state.write("}");
    }
    const quasi = quasis[quasis.length - 1];
    state.write(quasi.value.raw, quasi);
    state.write("`");
  },
  TemplateElement(node2, state) {
    state.write(node2.value.raw, node2);
  },
  TaggedTemplateExpression(node2, state) {
    formatExpression(state, node2.tag, node2);
    this[node2.quasi.type](node2.quasi, state);
  },
  ArrayExpression: ArrayExpression = function(node2, state) {
    state.write("[");
    if (node2.elements.length > 0) {
      const { elements } = node2, { length } = elements;
      for (let i = 0; ; ) {
        const element2 = elements[i];
        if (element2 != null) {
          this[element2.type](element2, state);
        }
        if (++i < length) {
          state.write(", ");
        } else {
          if (element2 == null) {
            state.write(", ");
          }
          break;
        }
      }
    }
    state.write("]");
  },
  ArrayPattern: ArrayExpression,
  ObjectExpression(node2, state) {
    const indent = state.indent.repeat(state.indentLevel++);
    const { lineEnd, writeComments } = state;
    const propertyIndent = indent + state.indent;
    state.write("{");
    if (node2.properties.length > 0) {
      state.write(lineEnd);
      if (writeComments && node2.comments != null) {
        formatComments(state, node2.comments, propertyIndent, lineEnd);
      }
      const comma = "," + lineEnd;
      const { properties } = node2, { length } = properties;
      for (let i = 0; ; ) {
        const property = properties[i];
        if (writeComments && property.comments != null) {
          formatComments(state, property.comments, propertyIndent, lineEnd);
        }
        state.write(propertyIndent);
        this[property.type](property, state);
        if (++i < length) {
          state.write(comma);
        } else {
          break;
        }
      }
      state.write(lineEnd);
      if (writeComments && node2.trailingComments != null) {
        formatComments(state, node2.trailingComments, propertyIndent, lineEnd);
      }
      state.write(indent + "}");
    } else if (writeComments) {
      if (node2.comments != null) {
        state.write(lineEnd);
        formatComments(state, node2.comments, propertyIndent, lineEnd);
        if (node2.trailingComments != null) {
          formatComments(state, node2.trailingComments, propertyIndent, lineEnd);
        }
        state.write(indent + "}");
      } else if (node2.trailingComments != null) {
        state.write(lineEnd);
        formatComments(state, node2.trailingComments, propertyIndent, lineEnd);
        state.write(indent + "}");
      } else {
        state.write("}");
      }
    } else {
      state.write("}");
    }
    state.indentLevel--;
  },
  Property(node2, state) {
    if (node2.method || node2.kind[0] !== "i") {
      this.MethodDefinition(node2, state);
    } else {
      if (!node2.shorthand) {
        if (node2.computed) {
          state.write("[");
          this[node2.key.type](node2.key, state);
          state.write("]");
        } else {
          this[node2.key.type](node2.key, state);
        }
        state.write(": ");
      }
      this[node2.value.type](node2.value, state);
    }
  },
  PropertyDefinition(node2, state) {
    if (node2.static) {
      state.write("static ");
    }
    if (node2.computed) {
      state.write("[");
    }
    this[node2.key.type](node2.key, state);
    if (node2.computed) {
      state.write("]");
    }
    if (node2.value == null) {
      if (node2.key.type[0] !== "F") {
        state.write(";");
      }
      return;
    }
    state.write(" = ");
    this[node2.value.type](node2.value, state);
    state.write(";");
  },
  ObjectPattern(node2, state) {
    state.write("{");
    if (node2.properties.length > 0) {
      const { properties } = node2, { length } = properties;
      for (let i = 0; ; ) {
        this[properties[i].type](properties[i], state);
        if (++i < length) {
          state.write(", ");
        } else {
          break;
        }
      }
    }
    state.write("}");
  },
  SequenceExpression(node2, state) {
    formatSequence(state, node2.expressions);
  },
  UnaryExpression(node2, state) {
    if (node2.prefix) {
      const {
        operator,
        argument,
        argument: { type }
      } = node2;
      state.write(operator);
      const needsParentheses = expressionNeedsParenthesis(state, argument, node2);
      if (!needsParentheses && (operator.length > 1 || type[0] === "U" && (type[1] === "n" || type[1] === "p") && argument.prefix && argument.operator[0] === operator && (operator === "+" || operator === "-"))) {
        state.write(" ");
      }
      if (needsParentheses) {
        state.write(operator.length > 1 ? " (" : "(");
        this[type](argument, state);
        state.write(")");
      } else {
        this[type](argument, state);
      }
    } else {
      this[node2.argument.type](node2.argument, state);
      state.write(node2.operator);
    }
  },
  UpdateExpression(node2, state) {
    if (node2.prefix) {
      state.write(node2.operator);
      this[node2.argument.type](node2.argument, state);
    } else {
      this[node2.argument.type](node2.argument, state);
      state.write(node2.operator);
    }
  },
  AssignmentExpression(node2, state) {
    this[node2.left.type](node2.left, state);
    state.write(" " + node2.operator + " ");
    this[node2.right.type](node2.right, state);
  },
  AssignmentPattern(node2, state) {
    this[node2.left.type](node2.left, state);
    state.write(" = ");
    this[node2.right.type](node2.right, state);
  },
  BinaryExpression: BinaryExpression = function(node2, state) {
    const isIn = node2.operator === "in";
    if (isIn) {
      state.write("(");
    }
    formatExpression(state, node2.left, node2, false);
    state.write(" " + node2.operator + " ");
    formatExpression(state, node2.right, node2, true);
    if (isIn) {
      state.write(")");
    }
  },
  LogicalExpression: BinaryExpression,
  ConditionalExpression(node2, state) {
    const { test } = node2;
    const precedence = state.expressionsPrecedence[test.type];
    if (precedence === NEEDS_PARENTHESES || precedence <= state.expressionsPrecedence.ConditionalExpression) {
      state.write("(");
      this[test.type](test, state);
      state.write(")");
    } else {
      this[test.type](test, state);
    }
    state.write(" ? ");
    this[node2.consequent.type](node2.consequent, state);
    state.write(" : ");
    this[node2.alternate.type](node2.alternate, state);
  },
  NewExpression(node2, state) {
    state.write("new ");
    const precedence = state.expressionsPrecedence[node2.callee.type];
    if (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.CallExpression || hasCallExpression(node2.callee)) {
      state.write("(");
      this[node2.callee.type](node2.callee, state);
      state.write(")");
    } else {
      this[node2.callee.type](node2.callee, state);
    }
    formatSequence(state, node2["arguments"]);
  },
  CallExpression(node2, state) {
    const precedence = state.expressionsPrecedence[node2.callee.type];
    if (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.CallExpression) {
      state.write("(");
      this[node2.callee.type](node2.callee, state);
      state.write(")");
    } else {
      this[node2.callee.type](node2.callee, state);
    }
    if (node2.optional) {
      state.write("?.");
    }
    formatSequence(state, node2["arguments"]);
  },
  ChainExpression(node2, state) {
    this[node2.expression.type](node2.expression, state);
  },
  MemberExpression(node2, state) {
    const precedence = state.expressionsPrecedence[node2.object.type];
    if (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.MemberExpression) {
      state.write("(");
      this[node2.object.type](node2.object, state);
      state.write(")");
    } else {
      this[node2.object.type](node2.object, state);
    }
    if (node2.computed) {
      if (node2.optional) {
        state.write("?.");
      }
      state.write("[");
      this[node2.property.type](node2.property, state);
      state.write("]");
    } else {
      if (node2.optional) {
        state.write("?.");
      } else {
        state.write(".");
      }
      this[node2.property.type](node2.property, state);
    }
  },
  MetaProperty(node2, state) {
    state.write(node2.meta.name + "." + node2.property.name, node2);
  },
  Identifier(node2, state) {
    state.write(node2.name, node2);
  },
  PrivateIdentifier(node2, state) {
    state.write(`#${node2.name}`, node2);
  },
  Literal(node2, state) {
    if (node2.raw != null) {
      state.write(node2.raw, node2);
    } else if (node2.regex != null) {
      this.RegExpLiteral(node2, state);
    } else if (node2.bigint != null) {
      state.write(node2.bigint + "n", node2);
    } else {
      state.write(stringify(node2.value), node2);
    }
  },
  RegExpLiteral(node2, state) {
    const { regex: regex2 } = node2;
    state.write(`/${regex2.pattern}/${regex2.flags}`, node2);
  }
};
var EMPTY_OBJECT = {};
var State = class {
  constructor(options) {
    const setup = options == null ? EMPTY_OBJECT : options;
    this.output = "";
    if (setup.output != null) {
      this.output = setup.output;
      this.write = this.writeToStream;
    } else {
      this.output = "";
    }
    this.generator = setup.generator != null ? setup.generator : GENERATOR;
    this.expressionsPrecedence = setup.expressionsPrecedence != null ? setup.expressionsPrecedence : EXPRESSIONS_PRECEDENCE;
    this.indent = setup.indent != null ? setup.indent : "  ";
    this.lineEnd = setup.lineEnd != null ? setup.lineEnd : "\n";
    this.indentLevel = setup.startingIndentLevel != null ? setup.startingIndentLevel : 0;
    this.writeComments = setup.comments ? setup.comments : false;
    if (setup.sourceMap != null) {
      this.write = setup.output == null ? this.writeAndMap : this.writeToStreamAndMap;
      this.sourceMap = setup.sourceMap;
      this.line = 1;
      this.column = 0;
      this.lineEndSize = this.lineEnd.split("\n").length - 1;
      this.mapping = {
        original: null,
        // Uses the entire state to avoid generating ephemeral objects
        generated: this,
        name: void 0,
        source: setup.sourceMap.file || setup.sourceMap._file
      };
    }
  }
  write(code2) {
    this.output += code2;
  }
  writeToStream(code2) {
    this.output.write(code2);
  }
  writeAndMap(code2, node2) {
    this.output += code2;
    this.map(code2, node2);
  }
  writeToStreamAndMap(code2, node2) {
    this.output.write(code2);
    this.map(code2, node2);
  }
  map(code2, node2) {
    if (node2 != null) {
      const { type } = node2;
      if (type[0] === "L" && type[2] === "n") {
        this.column = 0;
        this.line++;
        return;
      }
      if (node2.loc != null) {
        const { mapping } = this;
        mapping.original = node2.loc.start;
        mapping.name = node2.name;
        this.sourceMap.addMapping(mapping);
      }
      if (type[0] === "T" && type[8] === "E" || type[0] === "L" && type[1] === "i" && typeof node2.value === "string") {
        const { length: length2 } = code2;
        let { column: column2, line: line2 } = this;
        for (let i = 0; i < length2; i++) {
          if (code2[i] === "\n") {
            column2 = 0;
            line2++;
          } else {
            column2++;
          }
        }
        this.column = column2;
        this.line = line2;
        return;
      }
    }
    const { length } = code2;
    const { lineEnd } = this;
    if (length > 0) {
      if (this.lineEndSize > 0 && (lineEnd.length === 1 ? code2[length - 1] === lineEnd : code2.endsWith(lineEnd))) {
        this.line += this.lineEndSize;
        this.column = 0;
      } else {
        this.column += length;
      }
    }
  }
  toString() {
    return this.output;
  }
};
function generate(node2, options) {
  const state = new State(options);
  state.generator[node2.type](node2, state);
  return state.output;
}

// node_modules/estree-util-to-js/lib/index.js
var GENERATOR2 = GENERATOR;
var generate2 = generate;
var toJs = (
  /**
   * @type {(
   *   ((value: Program, options: OptionsWithSourceMapGenerator) => ResultWithSourceMapGenerator) &
   *   ((value: Program, options: OptionsWithMaybeMapGenerator) => ResultMaybeSourceMapGenerator) &
   *   ((value: Program, options?: OptionsWithoutSourceMapGenerator | null | undefined) => ResultWithoutSourceMapGenerator)
   * )}
   */
  /**
   * @param {Program} tree
   * @param {Options | null | undefined} [options]
   * @returns {Result}
   */
  function(tree, options) {
    const { SourceMapGenerator, filePath, handlers: handlers3 } = options || {};
    const sourceMap = SourceMapGenerator ? new SourceMapGenerator({ file: filePath || "<unknown>.js" }) : void 0;
    const value2 = generate2(tree, {
      comments: true,
      generator: { ...GENERATOR2, ...handlers3 },
      sourceMap
    });
    const map = sourceMap ? sourceMap.toJSON() : void 0;
    return { value: value2, map };
  }
);

// node_modules/estree-util-to-js/lib/jsx.js
var jsx = {
  JSXAttribute,
  JSXClosingElement,
  JSXClosingFragment,
  JSXElement,
  JSXEmptyExpression,
  JSXExpressionContainer,
  JSXFragment,
  JSXIdentifier,
  JSXMemberExpression,
  JSXNamespacedName,
  JSXOpeningElement,
  JSXOpeningFragment,
  JSXSpreadAttribute,
  JSXText
};
function JSXAttribute(node2, state) {
  this[node2.name.type](node2.name, state);
  if (node2.value !== void 0 && node2.value !== null) {
    state.write("=");
    if (node2.value.type === "Literal") {
      state.write(
        '"' + encodeJsx(String(node2.value.value)).replace(/"/g, "&quot;") + '"',
        node2
      );
    } else {
      this[node2.value.type](node2.value, state);
    }
  }
}
function JSXClosingElement(node2, state) {
  state.write("</");
  this[node2.name.type](node2.name, state);
  state.write(">");
}
function JSXClosingFragment(node2, state) {
  state.write("</>", node2);
}
function JSXElement(node2, state) {
  let index2 = -1;
  this[node2.openingElement.type](node2.openingElement, state);
  if (node2.children) {
    while (++index2 < node2.children.length) {
      const child = node2.children[index2];
      if (child.type === "JSXSpreadChild") {
        throw new Error("JSX spread children are not supported");
      }
      this[child.type](child, state);
    }
  }
  if (node2.closingElement) {
    this[node2.closingElement.type](node2.closingElement, state);
  }
}
function JSXEmptyExpression() {
}
function JSXExpressionContainer(node2, state) {
  state.write("{");
  this[node2.expression.type](node2.expression, state);
  state.write("}");
}
function JSXFragment(node2, state) {
  let index2 = -1;
  this[node2.openingFragment.type](node2.openingFragment, state);
  if (node2.children) {
    while (++index2 < node2.children.length) {
      const child = node2.children[index2];
      if (child.type === "JSXSpreadChild") {
        throw new Error("JSX spread children are not supported");
      }
      this[child.type](child, state);
    }
  }
  this[node2.closingFragment.type](node2.closingFragment, state);
}
function JSXIdentifier(node2, state) {
  state.write(node2.name, node2);
}
function JSXMemberExpression(node2, state) {
  this[node2.object.type](node2.object, state);
  state.write(".");
  this[node2.property.type](node2.property, state);
}
function JSXNamespacedName(node2, state) {
  this[node2.namespace.type](node2.namespace, state);
  state.write(":");
  this[node2.name.type](node2.name, state);
}
function JSXOpeningElement(node2, state) {
  let index2 = -1;
  state.write("<");
  this[node2.name.type](node2.name, state);
  if (node2.attributes) {
    while (++index2 < node2.attributes.length) {
      state.write(" ");
      this[node2.attributes[index2].type](node2.attributes[index2], state);
    }
  }
  state.write(node2.selfClosing ? " />" : ">");
}
function JSXOpeningFragment(node2, state) {
  state.write("<>", node2);
}
function JSXSpreadAttribute(node2, state) {
  state.write("{");
  this.SpreadElement(node2, state);
  state.write("}");
}
function JSXText(node2, state) {
  state.write(
    encodeJsx(node2.value).replace(
      /[<>{}]/g,
      ($0) => $0 === "<" ? "&lt;" : $0 === ">" ? "&gt;" : $0 === "{" ? "&#123;" : "&#125;"
    ),
    node2
  );
}
function encodeJsx(value2) {
  return value2.replace(/&(?=[#a-z])/gi, "&amp;");
}

// node_modules/@mdx-js/mdx/lib/plugin/recma-stringify.js
function recmaStringify(options) {
  const { SourceMapGenerator } = options || {};
  Object.assign(this, { Compiler: compiler2 });
  function compiler2(tree, file) {
    const result = SourceMapGenerator ? toJs(tree, {
      filePath: file.path || "unknown.mdx",
      SourceMapGenerator,
      handlers: jsx
    }) : toJs(tree, { handlers: jsx });
    file.map = result.map;
    return result.value;
  }
}

// node_modules/hast-util-to-estree/lib/handlers/comment.js
function comment(node2, state) {
  const result = { type: "Block", value: node2.value };
  state.inherit(node2, result);
  state.comments.push(result);
  const expression = {
    type: "JSXEmptyExpression",
    // @ts-expect-error: `comments` is custom.
    comments: [Object.assign({}, result, { leading: false, trailing: true })]
  };
  state.patch(node2, expression);
  const container = { type: "JSXExpressionContainer", expression };
  state.patch(node2, container);
  return container;
}

// node_modules/comma-separated-tokens/index.js
function stringify2(values, options) {
  const settings = options || {};
  const input = values[values.length - 1] === "" ? [...values, ""] : values;
  return input.join(
    (settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")
  ).trim();
}

// node_modules/property-information/lib/util/schema.js
var Schema = class {
  /**
   * @constructor
   * @param {Properties} property
   * @param {Normal} normal
   * @param {string} [space]
   */
  constructor(property, normal, space2) {
    this.property = property;
    this.normal = normal;
    if (space2) {
      this.space = space2;
    }
  }
};
Schema.prototype.property = {};
Schema.prototype.normal = {};
Schema.prototype.space = null;

// node_modules/property-information/lib/util/merge.js
function merge(definitions2, space2) {
  const property = {};
  const normal = {};
  let index2 = -1;
  while (++index2 < definitions2.length) {
    Object.assign(property, definitions2[index2].property);
    Object.assign(normal, definitions2[index2].normal);
  }
  return new Schema(property, normal, space2);
}

// node_modules/property-information/lib/normalize.js
function normalize(value2) {
  return value2.toLowerCase();
}

// node_modules/property-information/lib/util/info.js
var Info = class {
  /**
   * @constructor
   * @param {string} property
   * @param {string} attribute
   */
  constructor(property, attribute) {
    this.property = property;
    this.attribute = attribute;
  }
};
Info.prototype.space = null;
Info.prototype.boolean = false;
Info.prototype.booleanish = false;
Info.prototype.overloadedBoolean = false;
Info.prototype.number = false;
Info.prototype.commaSeparated = false;
Info.prototype.spaceSeparated = false;
Info.prototype.commaOrSpaceSeparated = false;
Info.prototype.mustUseProperty = false;
Info.prototype.defined = false;

// node_modules/property-information/lib/util/types.js
var types_exports = {};
__export(types_exports, {
  boolean: () => boolean,
  booleanish: () => booleanish,
  commaOrSpaceSeparated: () => commaOrSpaceSeparated,
  commaSeparated: () => commaSeparated,
  number: () => number,
  overloadedBoolean: () => overloadedBoolean,
  spaceSeparated: () => spaceSeparated
});
var powers = 0;
var boolean = increment();
var booleanish = increment();
var overloadedBoolean = increment();
var number = increment();
var spaceSeparated = increment();
var commaSeparated = increment();
var commaOrSpaceSeparated = increment();
function increment() {
  return 2 ** ++powers;
}

// node_modules/property-information/lib/util/defined-info.js
var checks = Object.keys(types_exports);
var DefinedInfo = class extends Info {
  /**
   * @constructor
   * @param {string} property
   * @param {string} attribute
   * @param {number|null} [mask]
   * @param {string} [space]
   */
  constructor(property, attribute, mask, space2) {
    let index2 = -1;
    super(property, attribute);
    mark(this, "space", space2);
    if (typeof mask === "number") {
      while (++index2 < checks.length) {
        const check = checks[index2];
        mark(this, checks[index2], (mask & types_exports[check]) === types_exports[check]);
      }
    }
  }
};
DefinedInfo.prototype.defined = true;
function mark(values, key2, value2) {
  if (value2) {
    values[key2] = value2;
  }
}

// node_modules/property-information/lib/util/create.js
var own8 = {}.hasOwnProperty;
function create3(definition2) {
  const property = {};
  const normal = {};
  let prop;
  for (prop in definition2.properties) {
    if (own8.call(definition2.properties, prop)) {
      const value2 = definition2.properties[prop];
      const info = new DefinedInfo(
        prop,
        definition2.transform(definition2.attributes || {}, prop),
        value2,
        definition2.space
      );
      if (definition2.mustUseProperty && definition2.mustUseProperty.includes(prop)) {
        info.mustUseProperty = true;
      }
      property[prop] = info;
      normal[normalize(prop)] = prop;
      normal[normalize(info.attribute)] = prop;
    }
  }
  return new Schema(property, normal, definition2.space);
}

// node_modules/property-information/lib/xlink.js
var xlink = create3({
  space: "xlink",
  transform(_, prop) {
    return "xlink:" + prop.slice(5).toLowerCase();
  },
  properties: {
    xLinkActuate: null,
    xLinkArcRole: null,
    xLinkHref: null,
    xLinkRole: null,
    xLinkShow: null,
    xLinkTitle: null,
    xLinkType: null
  }
});

// node_modules/property-information/lib/xml.js
var xml = create3({
  space: "xml",
  transform(_, prop) {
    return "xml:" + prop.slice(3).toLowerCase();
  },
  properties: { xmlLang: null, xmlBase: null, xmlSpace: null }
});

// node_modules/property-information/lib/util/case-sensitive-transform.js
function caseSensitiveTransform(attributes, attribute) {
  return attribute in attributes ? attributes[attribute] : attribute;
}

// node_modules/property-information/lib/util/case-insensitive-transform.js
function caseInsensitiveTransform(attributes, property) {
  return caseSensitiveTransform(attributes, property.toLowerCase());
}

// node_modules/property-information/lib/xmlns.js
var xmlns = create3({
  space: "xmlns",
  attributes: { xmlnsxlink: "xmlns:xlink" },
  transform: caseInsensitiveTransform,
  properties: { xmlns: null, xmlnsXLink: null }
});

// node_modules/property-information/lib/aria.js
var aria = create3({
  transform(_, prop) {
    return prop === "role" ? prop : "aria-" + prop.slice(4).toLowerCase();
  },
  properties: {
    ariaActiveDescendant: null,
    ariaAtomic: booleanish,
    ariaAutoComplete: null,
    ariaBusy: booleanish,
    ariaChecked: booleanish,
    ariaColCount: number,
    ariaColIndex: number,
    ariaColSpan: number,
    ariaControls: spaceSeparated,
    ariaCurrent: null,
    ariaDescribedBy: spaceSeparated,
    ariaDetails: null,
    ariaDisabled: booleanish,
    ariaDropEffect: spaceSeparated,
    ariaErrorMessage: null,
    ariaExpanded: booleanish,
    ariaFlowTo: spaceSeparated,
    ariaGrabbed: booleanish,
    ariaHasPopup: null,
    ariaHidden: booleanish,
    ariaInvalid: null,
    ariaKeyShortcuts: null,
    ariaLabel: null,
    ariaLabelledBy: spaceSeparated,
    ariaLevel: number,
    ariaLive: null,
    ariaModal: booleanish,
    ariaMultiLine: booleanish,
    ariaMultiSelectable: booleanish,
    ariaOrientation: null,
    ariaOwns: spaceSeparated,
    ariaPlaceholder: null,
    ariaPosInSet: number,
    ariaPressed: booleanish,
    ariaReadOnly: booleanish,
    ariaRelevant: null,
    ariaRequired: booleanish,
    ariaRoleDescription: spaceSeparated,
    ariaRowCount: number,
    ariaRowIndex: number,
    ariaRowSpan: number,
    ariaSelected: booleanish,
    ariaSetSize: number,
    ariaSort: null,
    ariaValueMax: number,
    ariaValueMin: number,
    ariaValueNow: number,
    ariaValueText: null,
    role: null
  }
});

// node_modules/property-information/lib/html.js
var html2 = create3({
  space: "html",
  attributes: {
    acceptcharset: "accept-charset",
    classname: "class",
    htmlfor: "for",
    httpequiv: "http-equiv"
  },
  transform: caseInsensitiveTransform,
  mustUseProperty: ["checked", "multiple", "muted", "selected"],
  properties: {
    // Standard Properties.
    abbr: null,
    accept: commaSeparated,
    acceptCharset: spaceSeparated,
    accessKey: spaceSeparated,
    action: null,
    allow: null,
    allowFullScreen: boolean,
    allowPaymentRequest: boolean,
    allowUserMedia: boolean,
    alt: null,
    as: null,
    async: boolean,
    autoCapitalize: null,
    autoComplete: spaceSeparated,
    autoFocus: boolean,
    autoPlay: boolean,
    capture: boolean,
    charSet: null,
    checked: boolean,
    cite: null,
    className: spaceSeparated,
    cols: number,
    colSpan: null,
    content: null,
    contentEditable: booleanish,
    controls: boolean,
    controlsList: spaceSeparated,
    coords: number | commaSeparated,
    crossOrigin: null,
    data: null,
    dateTime: null,
    decoding: null,
    default: boolean,
    defer: boolean,
    dir: null,
    dirName: null,
    disabled: boolean,
    download: overloadedBoolean,
    draggable: booleanish,
    encType: null,
    enterKeyHint: null,
    form: null,
    formAction: null,
    formEncType: null,
    formMethod: null,
    formNoValidate: boolean,
    formTarget: null,
    headers: spaceSeparated,
    height: number,
    hidden: boolean,
    high: number,
    href: null,
    hrefLang: null,
    htmlFor: spaceSeparated,
    httpEquiv: spaceSeparated,
    id: null,
    imageSizes: null,
    imageSrcSet: null,
    inputMode: null,
    integrity: null,
    is: null,
    isMap: boolean,
    itemId: null,
    itemProp: spaceSeparated,
    itemRef: spaceSeparated,
    itemScope: boolean,
    itemType: spaceSeparated,
    kind: null,
    label: null,
    lang: null,
    language: null,
    list: null,
    loading: null,
    loop: boolean,
    low: number,
    manifest: null,
    max: null,
    maxLength: number,
    media: null,
    method: null,
    min: null,
    minLength: number,
    multiple: boolean,
    muted: boolean,
    name: null,
    nonce: null,
    noModule: boolean,
    noValidate: boolean,
    onAbort: null,
    onAfterPrint: null,
    onAuxClick: null,
    onBeforeMatch: null,
    onBeforePrint: null,
    onBeforeUnload: null,
    onBlur: null,
    onCancel: null,
    onCanPlay: null,
    onCanPlayThrough: null,
    onChange: null,
    onClick: null,
    onClose: null,
    onContextLost: null,
    onContextMenu: null,
    onContextRestored: null,
    onCopy: null,
    onCueChange: null,
    onCut: null,
    onDblClick: null,
    onDrag: null,
    onDragEnd: null,
    onDragEnter: null,
    onDragExit: null,
    onDragLeave: null,
    onDragOver: null,
    onDragStart: null,
    onDrop: null,
    onDurationChange: null,
    onEmptied: null,
    onEnded: null,
    onError: null,
    onFocus: null,
    onFormData: null,
    onHashChange: null,
    onInput: null,
    onInvalid: null,
    onKeyDown: null,
    onKeyPress: null,
    onKeyUp: null,
    onLanguageChange: null,
    onLoad: null,
    onLoadedData: null,
    onLoadedMetadata: null,
    onLoadEnd: null,
    onLoadStart: null,
    onMessage: null,
    onMessageError: null,
    onMouseDown: null,
    onMouseEnter: null,
    onMouseLeave: null,
    onMouseMove: null,
    onMouseOut: null,
    onMouseOver: null,
    onMouseUp: null,
    onOffline: null,
    onOnline: null,
    onPageHide: null,
    onPageShow: null,
    onPaste: null,
    onPause: null,
    onPlay: null,
    onPlaying: null,
    onPopState: null,
    onProgress: null,
    onRateChange: null,
    onRejectionHandled: null,
    onReset: null,
    onResize: null,
    onScroll: null,
    onScrollEnd: null,
    onSecurityPolicyViolation: null,
    onSeeked: null,
    onSeeking: null,
    onSelect: null,
    onSlotChange: null,
    onStalled: null,
    onStorage: null,
    onSubmit: null,
    onSuspend: null,
    onTimeUpdate: null,
    onToggle: null,
    onUnhandledRejection: null,
    onUnload: null,
    onVolumeChange: null,
    onWaiting: null,
    onWheel: null,
    open: boolean,
    optimum: number,
    pattern: null,
    ping: spaceSeparated,
    placeholder: null,
    playsInline: boolean,
    poster: null,
    preload: null,
    readOnly: boolean,
    referrerPolicy: null,
    rel: spaceSeparated,
    required: boolean,
    reversed: boolean,
    rows: number,
    rowSpan: number,
    sandbox: spaceSeparated,
    scope: null,
    scoped: boolean,
    seamless: boolean,
    selected: boolean,
    shape: null,
    size: number,
    sizes: null,
    slot: null,
    span: number,
    spellCheck: booleanish,
    src: null,
    srcDoc: null,
    srcLang: null,
    srcSet: null,
    start: number,
    step: null,
    style: null,
    tabIndex: number,
    target: null,
    title: null,
    translate: null,
    type: null,
    typeMustMatch: boolean,
    useMap: null,
    value: booleanish,
    width: number,
    wrap: null,
    // Legacy.
    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
    align: null,
    // Several. Use CSS `text-align` instead,
    aLink: null,
    // `<body>`. Use CSS `a:active {color}` instead
    archive: spaceSeparated,
    // `<object>`. List of URIs to archives
    axis: null,
    // `<td>` and `<th>`. Use `scope` on `<th>`
    background: null,
    // `<body>`. Use CSS `background-image` instead
    bgColor: null,
    // `<body>` and table elements. Use CSS `background-color` instead
    border: number,
    // `<table>`. Use CSS `border-width` instead,
    borderColor: null,
    // `<table>`. Use CSS `border-color` instead,
    bottomMargin: number,
    // `<body>`
    cellPadding: null,
    // `<table>`
    cellSpacing: null,
    // `<table>`
    char: null,
    // Several table elements. When `align=char`, sets the character to align on
    charOff: null,
    // Several table elements. When `char`, offsets the alignment
    classId: null,
    // `<object>`
    clear: null,
    // `<br>`. Use CSS `clear` instead
    code: null,
    // `<object>`
    codeBase: null,
    // `<object>`
    codeType: null,
    // `<object>`
    color: null,
    // `<font>` and `<hr>`. Use CSS instead
    compact: boolean,
    // Lists. Use CSS to reduce space between items instead
    declare: boolean,
    // `<object>`
    event: null,
    // `<script>`
    face: null,
    // `<font>`. Use CSS instead
    frame: null,
    // `<table>`
    frameBorder: null,
    // `<iframe>`. Use CSS `border` instead
    hSpace: number,
    // `<img>` and `<object>`
    leftMargin: number,
    // `<body>`
    link: null,
    // `<body>`. Use CSS `a:link {color: *}` instead
    longDesc: null,
    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
    lowSrc: null,
    // `<img>`. Use a `<picture>`
    marginHeight: number,
    // `<body>`
    marginWidth: number,
    // `<body>`
    noResize: boolean,
    // `<frame>`
    noHref: boolean,
    // `<area>`. Use no href instead of an explicit `nohref`
    noShade: boolean,
    // `<hr>`. Use background-color and height instead of borders
    noWrap: boolean,
    // `<td>` and `<th>`
    object: null,
    // `<applet>`
    profile: null,
    // `<head>`
    prompt: null,
    // `<isindex>`
    rev: null,
    // `<link>`
    rightMargin: number,
    // `<body>`
    rules: null,
    // `<table>`
    scheme: null,
    // `<meta>`
    scrolling: booleanish,
    // `<frame>`. Use overflow in the child context
    standby: null,
    // `<object>`
    summary: null,
    // `<table>`
    text: null,
    // `<body>`. Use CSS `color` instead
    topMargin: number,
    // `<body>`
    valueType: null,
    // `<param>`
    version: null,
    // `<html>`. Use a doctype.
    vAlign: null,
    // Several. Use CSS `vertical-align` instead
    vLink: null,
    // `<body>`. Use CSS `a:visited {color}` instead
    vSpace: number,
    // `<img>` and `<object>`
    // Non-standard Properties.
    allowTransparency: null,
    autoCorrect: null,
    autoSave: null,
    disablePictureInPicture: boolean,
    disableRemotePlayback: boolean,
    prefix: null,
    property: null,
    results: number,
    security: null,
    unselectable: null
  }
});

// node_modules/property-information/lib/svg.js
var svg = create3({
  space: "svg",
  attributes: {
    accentHeight: "accent-height",
    alignmentBaseline: "alignment-baseline",
    arabicForm: "arabic-form",
    baselineShift: "baseline-shift",
    capHeight: "cap-height",
    className: "class",
    clipPath: "clip-path",
    clipRule: "clip-rule",
    colorInterpolation: "color-interpolation",
    colorInterpolationFilters: "color-interpolation-filters",
    colorProfile: "color-profile",
    colorRendering: "color-rendering",
    crossOrigin: "crossorigin",
    dataType: "datatype",
    dominantBaseline: "dominant-baseline",
    enableBackground: "enable-background",
    fillOpacity: "fill-opacity",
    fillRule: "fill-rule",
    floodColor: "flood-color",
    floodOpacity: "flood-opacity",
    fontFamily: "font-family",
    fontSize: "font-size",
    fontSizeAdjust: "font-size-adjust",
    fontStretch: "font-stretch",
    fontStyle: "font-style",
    fontVariant: "font-variant",
    fontWeight: "font-weight",
    glyphName: "glyph-name",
    glyphOrientationHorizontal: "glyph-orientation-horizontal",
    glyphOrientationVertical: "glyph-orientation-vertical",
    hrefLang: "hreflang",
    horizAdvX: "horiz-adv-x",
    horizOriginX: "horiz-origin-x",
    horizOriginY: "horiz-origin-y",
    imageRendering: "image-rendering",
    letterSpacing: "letter-spacing",
    lightingColor: "lighting-color",
    markerEnd: "marker-end",
    markerMid: "marker-mid",
    markerStart: "marker-start",
    navDown: "nav-down",
    navDownLeft: "nav-down-left",
    navDownRight: "nav-down-right",
    navLeft: "nav-left",
    navNext: "nav-next",
    navPrev: "nav-prev",
    navRight: "nav-right",
    navUp: "nav-up",
    navUpLeft: "nav-up-left",
    navUpRight: "nav-up-right",
    onAbort: "onabort",
    onActivate: "onactivate",
    onAfterPrint: "onafterprint",
    onBeforePrint: "onbeforeprint",
    onBegin: "onbegin",
    onCancel: "oncancel",
    onCanPlay: "oncanplay",
    onCanPlayThrough: "oncanplaythrough",
    onChange: "onchange",
    onClick: "onclick",
    onClose: "onclose",
    onCopy: "oncopy",
    onCueChange: "oncuechange",
    onCut: "oncut",
    onDblClick: "ondblclick",
    onDrag: "ondrag",
    onDragEnd: "ondragend",
    onDragEnter: "ondragenter",
    onDragExit: "ondragexit",
    onDragLeave: "ondragleave",
    onDragOver: "ondragover",
    onDragStart: "ondragstart",
    onDrop: "ondrop",
    onDurationChange: "ondurationchange",
    onEmptied: "onemptied",
    onEnd: "onend",
    onEnded: "onended",
    onError: "onerror",
    onFocus: "onfocus",
    onFocusIn: "onfocusin",
    onFocusOut: "onfocusout",
    onHashChange: "onhashchange",
    onInput: "oninput",
    onInvalid: "oninvalid",
    onKeyDown: "onkeydown",
    onKeyPress: "onkeypress",
    onKeyUp: "onkeyup",
    onLoad: "onload",
    onLoadedData: "onloadeddata",
    onLoadedMetadata: "onloadedmetadata",
    onLoadStart: "onloadstart",
    onMessage: "onmessage",
    onMouseDown: "onmousedown",
    onMouseEnter: "onmouseenter",
    onMouseLeave: "onmouseleave",
    onMouseMove: "onmousemove",
    onMouseOut: "onmouseout",
    onMouseOver: "onmouseover",
    onMouseUp: "onmouseup",
    onMouseWheel: "onmousewheel",
    onOffline: "onoffline",
    onOnline: "ononline",
    onPageHide: "onpagehide",
    onPageShow: "onpageshow",
    onPaste: "onpaste",
    onPause: "onpause",
    onPlay: "onplay",
    onPlaying: "onplaying",
    onPopState: "onpopstate",
    onProgress: "onprogress",
    onRateChange: "onratechange",
    onRepeat: "onrepeat",
    onReset: "onreset",
    onResize: "onresize",
    onScroll: "onscroll",
    onSeeked: "onseeked",
    onSeeking: "onseeking",
    onSelect: "onselect",
    onShow: "onshow",
    onStalled: "onstalled",
    onStorage: "onstorage",
    onSubmit: "onsubmit",
    onSuspend: "onsuspend",
    onTimeUpdate: "ontimeupdate",
    onToggle: "ontoggle",
    onUnload: "onunload",
    onVolumeChange: "onvolumechange",
    onWaiting: "onwaiting",
    onZoom: "onzoom",
    overlinePosition: "overline-position",
    overlineThickness: "overline-thickness",
    paintOrder: "paint-order",
    panose1: "panose-1",
    pointerEvents: "pointer-events",
    referrerPolicy: "referrerpolicy",
    renderingIntent: "rendering-intent",
    shapeRendering: "shape-rendering",
    stopColor: "stop-color",
    stopOpacity: "stop-opacity",
    strikethroughPosition: "strikethrough-position",
    strikethroughThickness: "strikethrough-thickness",
    strokeDashArray: "stroke-dasharray",
    strokeDashOffset: "stroke-dashoffset",
    strokeLineCap: "stroke-linecap",
    strokeLineJoin: "stroke-linejoin",
    strokeMiterLimit: "stroke-miterlimit",
    strokeOpacity: "stroke-opacity",
    strokeWidth: "stroke-width",
    tabIndex: "tabindex",
    textAnchor: "text-anchor",
    textDecoration: "text-decoration",
    textRendering: "text-rendering",
    typeOf: "typeof",
    underlinePosition: "underline-position",
    underlineThickness: "underline-thickness",
    unicodeBidi: "unicode-bidi",
    unicodeRange: "unicode-range",
    unitsPerEm: "units-per-em",
    vAlphabetic: "v-alphabetic",
    vHanging: "v-hanging",
    vIdeographic: "v-ideographic",
    vMathematical: "v-mathematical",
    vectorEffect: "vector-effect",
    vertAdvY: "vert-adv-y",
    vertOriginX: "vert-origin-x",
    vertOriginY: "vert-origin-y",
    wordSpacing: "word-spacing",
    writingMode: "writing-mode",
    xHeight: "x-height",
    // These were camelcased in Tiny. Now lowercased in SVG 2
    playbackOrder: "playbackorder",
    timelineBegin: "timelinebegin"
  },
  transform: caseSensitiveTransform,
  properties: {
    about: commaOrSpaceSeparated,
    accentHeight: number,
    accumulate: null,
    additive: null,
    alignmentBaseline: null,
    alphabetic: number,
    amplitude: number,
    arabicForm: null,
    ascent: number,
    attributeName: null,
    attributeType: null,
    azimuth: number,
    bandwidth: null,
    baselineShift: null,
    baseFrequency: null,
    baseProfile: null,
    bbox: null,
    begin: null,
    bias: number,
    by: null,
    calcMode: null,
    capHeight: number,
    className: spaceSeparated,
    clip: null,
    clipPath: null,
    clipPathUnits: null,
    clipRule: null,
    color: null,
    colorInterpolation: null,
    colorInterpolationFilters: null,
    colorProfile: null,
    colorRendering: null,
    content: null,
    contentScriptType: null,
    contentStyleType: null,
    crossOrigin: null,
    cursor: null,
    cx: null,
    cy: null,
    d: null,
    dataType: null,
    defaultAction: null,
    descent: number,
    diffuseConstant: number,
    direction: null,
    display: null,
    dur: null,
    divisor: number,
    dominantBaseline: null,
    download: boolean,
    dx: null,
    dy: null,
    edgeMode: null,
    editable: null,
    elevation: number,
    enableBackground: null,
    end: null,
    event: null,
    exponent: number,
    externalResourcesRequired: null,
    fill: null,
    fillOpacity: number,
    fillRule: null,
    filter: null,
    filterRes: null,
    filterUnits: null,
    floodColor: null,
    floodOpacity: null,
    focusable: null,
    focusHighlight: null,
    fontFamily: null,
    fontSize: null,
    fontSizeAdjust: null,
    fontStretch: null,
    fontStyle: null,
    fontVariant: null,
    fontWeight: null,
    format: null,
    fr: null,
    from: null,
    fx: null,
    fy: null,
    g1: commaSeparated,
    g2: commaSeparated,
    glyphName: commaSeparated,
    glyphOrientationHorizontal: null,
    glyphOrientationVertical: null,
    glyphRef: null,
    gradientTransform: null,
    gradientUnits: null,
    handler: null,
    hanging: number,
    hatchContentUnits: null,
    hatchUnits: null,
    height: null,
    href: null,
    hrefLang: null,
    horizAdvX: number,
    horizOriginX: number,
    horizOriginY: number,
    id: null,
    ideographic: number,
    imageRendering: null,
    initialVisibility: null,
    in: null,
    in2: null,
    intercept: number,
    k: number,
    k1: number,
    k2: number,
    k3: number,
    k4: number,
    kernelMatrix: commaOrSpaceSeparated,
    kernelUnitLength: null,
    keyPoints: null,
    // SEMI_COLON_SEPARATED
    keySplines: null,
    // SEMI_COLON_SEPARATED
    keyTimes: null,
    // SEMI_COLON_SEPARATED
    kerning: null,
    lang: null,
    lengthAdjust: null,
    letterSpacing: null,
    lightingColor: null,
    limitingConeAngle: number,
    local: null,
    markerEnd: null,
    markerMid: null,
    markerStart: null,
    markerHeight: null,
    markerUnits: null,
    markerWidth: null,
    mask: null,
    maskContentUnits: null,
    maskUnits: null,
    mathematical: null,
    max: null,
    media: null,
    mediaCharacterEncoding: null,
    mediaContentEncodings: null,
    mediaSize: number,
    mediaTime: null,
    method: null,
    min: null,
    mode: null,
    name: null,
    navDown: null,
    navDownLeft: null,
    navDownRight: null,
    navLeft: null,
    navNext: null,
    navPrev: null,
    navRight: null,
    navUp: null,
    navUpLeft: null,
    navUpRight: null,
    numOctaves: null,
    observer: null,
    offset: null,
    onAbort: null,
    onActivate: null,
    onAfterPrint: null,
    onBeforePrint: null,
    onBegin: null,
    onCancel: null,
    onCanPlay: null,
    onCanPlayThrough: null,
    onChange: null,
    onClick: null,
    onClose: null,
    onCopy: null,
    onCueChange: null,
    onCut: null,
    onDblClick: null,
    onDrag: null,
    onDragEnd: null,
    onDragEnter: null,
    onDragExit: null,
    onDragLeave: null,
    onDragOver: null,
    onDragStart: null,
    onDrop: null,
    onDurationChange: null,
    onEmptied: null,
    onEnd: null,
    onEnded: null,
    onError: null,
    onFocus: null,
    onFocusIn: null,
    onFocusOut: null,
    onHashChange: null,
    onInput: null,
    onInvalid: null,
    onKeyDown: null,
    onKeyPress: null,
    onKeyUp: null,
    onLoad: null,
    onLoadedData: null,
    onLoadedMetadata: null,
    onLoadStart: null,
    onMessage: null,
    onMouseDown: null,
    onMouseEnter: null,
    onMouseLeave: null,
    onMouseMove: null,
    onMouseOut: null,
    onMouseOver: null,
    onMouseUp: null,
    onMouseWheel: null,
    onOffline: null,
    onOnline: null,
    onPageHide: null,
    onPageShow: null,
    onPaste: null,
    onPause: null,
    onPlay: null,
    onPlaying: null,
    onPopState: null,
    onProgress: null,
    onRateChange: null,
    onRepeat: null,
    onReset: null,
    onResize: null,
    onScroll: null,
    onSeeked: null,
    onSeeking: null,
    onSelect: null,
    onShow: null,
    onStalled: null,
    onStorage: null,
    onSubmit: null,
    onSuspend: null,
    onTimeUpdate: null,
    onToggle: null,
    onUnload: null,
    onVolumeChange: null,
    onWaiting: null,
    onZoom: null,
    opacity: null,
    operator: null,
    order: null,
    orient: null,
    orientation: null,
    origin: null,
    overflow: null,
    overlay: null,
    overlinePosition: number,
    overlineThickness: number,
    paintOrder: null,
    panose1: null,
    path: null,
    pathLength: number,
    patternContentUnits: null,
    patternTransform: null,
    patternUnits: null,
    phase: null,
    ping: spaceSeparated,
    pitch: null,
    playbackOrder: null,
    pointerEvents: null,
    points: null,
    pointsAtX: number,
    pointsAtY: number,
    pointsAtZ: number,
    preserveAlpha: null,
    preserveAspectRatio: null,
    primitiveUnits: null,
    propagate: null,
    property: commaOrSpaceSeparated,
    r: null,
    radius: null,
    referrerPolicy: null,
    refX: null,
    refY: null,
    rel: commaOrSpaceSeparated,
    rev: commaOrSpaceSeparated,
    renderingIntent: null,
    repeatCount: null,
    repeatDur: null,
    requiredExtensions: commaOrSpaceSeparated,
    requiredFeatures: commaOrSpaceSeparated,
    requiredFonts: commaOrSpaceSeparated,
    requiredFormats: commaOrSpaceSeparated,
    resource: null,
    restart: null,
    result: null,
    rotate: null,
    rx: null,
    ry: null,
    scale: null,
    seed: null,
    shapeRendering: null,
    side: null,
    slope: null,
    snapshotTime: null,
    specularConstant: number,
    specularExponent: number,
    spreadMethod: null,
    spacing: null,
    startOffset: null,
    stdDeviation: null,
    stemh: null,
    stemv: null,
    stitchTiles: null,
    stopColor: null,
    stopOpacity: null,
    strikethroughPosition: number,
    strikethroughThickness: number,
    string: null,
    stroke: null,
    strokeDashArray: commaOrSpaceSeparated,
    strokeDashOffset: null,
    strokeLineCap: null,
    strokeLineJoin: null,
    strokeMiterLimit: number,
    strokeOpacity: number,
    strokeWidth: null,
    style: null,
    surfaceScale: number,
    syncBehavior: null,
    syncBehaviorDefault: null,
    syncMaster: null,
    syncTolerance: null,
    syncToleranceDefault: null,
    systemLanguage: commaOrSpaceSeparated,
    tabIndex: number,
    tableValues: null,
    target: null,
    targetX: number,
    targetY: number,
    textAnchor: null,
    textDecoration: null,
    textRendering: null,
    textLength: null,
    timelineBegin: null,
    title: null,
    transformBehavior: null,
    type: null,
    typeOf: commaOrSpaceSeparated,
    to: null,
    transform: null,
    u1: null,
    u2: null,
    underlinePosition: number,
    underlineThickness: number,
    unicode: null,
    unicodeBidi: null,
    unicodeRange: null,
    unitsPerEm: number,
    values: null,
    vAlphabetic: number,
    vMathematical: number,
    vectorEffect: null,
    vHanging: number,
    vIdeographic: number,
    version: null,
    vertAdvY: number,
    vertOriginX: number,
    vertOriginY: number,
    viewBox: null,
    viewTarget: null,
    visibility: null,
    width: null,
    widths: null,
    wordSpacing: null,
    writingMode: null,
    x: null,
    x1: null,
    x2: null,
    xChannelSelector: null,
    xHeight: number,
    y: null,
    y1: null,
    y2: null,
    yChannelSelector: null,
    z: null,
    zoomAndPan: null
  }
});

// node_modules/property-information/lib/find.js
var valid = /^data[-\w.:]+$/i;
var dash = /-[a-z]/g;
var cap = /[A-Z]/g;
function find(schema, value2) {
  const normal = normalize(value2);
  let prop = value2;
  let Type = Info;
  if (normal in schema.normal) {
    return schema.property[schema.normal[normal]];
  }
  if (normal.length > 4 && normal.slice(0, 4) === "data" && valid.test(value2)) {
    if (value2.charAt(4) === "-") {
      const rest = value2.slice(5).replace(dash, camelcase);
      prop = "data" + rest.charAt(0).toUpperCase() + rest.slice(1);
    } else {
      const rest = value2.slice(4);
      if (!dash.test(rest)) {
        let dashes = rest.replace(cap, kebab);
        if (dashes.charAt(0) !== "-") {
          dashes = "-" + dashes;
        }
        value2 = "data" + dashes;
      }
    }
    Type = DefinedInfo;
  }
  return new Type(prop, value2);
}
function kebab($0) {
  return "-" + $0.toLowerCase();
}
function camelcase($0) {
  return $0.charAt(1).toUpperCase();
}

// node_modules/property-information/lib/hast-to-react.js
var hastToReact = {
  classId: "classID",
  dataType: "datatype",
  itemId: "itemID",
  strokeDashArray: "strokeDasharray",
  strokeDashOffset: "strokeDashoffset",
  strokeLineCap: "strokeLinecap",
  strokeLineJoin: "strokeLinejoin",
  strokeMiterLimit: "strokeMiterlimit",
  typeOf: "typeof",
  xLinkActuate: "xlinkActuate",
  xLinkArcRole: "xlinkArcrole",
  xLinkHref: "xlinkHref",
  xLinkRole: "xlinkRole",
  xLinkShow: "xlinkShow",
  xLinkTitle: "xlinkTitle",
  xLinkType: "xlinkType",
  xmlnsXLink: "xmlnsXlink"
};

// node_modules/property-information/index.js
var html3 = merge([xml, xlink, xmlns, aria, html2], "html");
var svg2 = merge([xml, xlink, xmlns, aria, svg], "svg");

// node_modules/space-separated-tokens/index.js
function stringify3(values) {
  return values.join(" ").trim();
}

// node_modules/style-to-object/index.mjs
var import_index = __toESM(require_style_to_object(), 1);
var style_to_object_default = import_index.default;

// node_modules/hast-util-to-estree/lib/handlers/element.js
var own9 = {}.hasOwnProperty;
var cap2 = /[A-Z]/g;
var dashSomething = /-([a-z])/g;
function element(node2, state) {
  const parentSchema = state.schema;
  let schema = parentSchema;
  const props = node2.properties || {};
  if (parentSchema.space === "html" && node2.tagName.toLowerCase() === "svg") {
    schema = svg2;
    state.schema = schema;
  }
  const children = state.all(node2);
  const attributes = [];
  let prop;
  for (prop in props) {
    if (own9.call(props, prop)) {
      let value2 = props[prop];
      const info = find(schema, prop);
      let attributeValue;
      if (value2 === void 0 || value2 === null || typeof value2 === "number" && Number.isNaN(value2) || value2 === false || !value2 && info.boolean) {
        continue;
      }
      prop = state.elementAttributeNameCase === "react" && info.space ? hastToReact[info.property] || info.property : info.attribute;
      if (Array.isArray(value2)) {
        value2 = info.commaSeparated ? stringify2(value2) : stringify3(value2);
      }
      if (prop === "style") {
        let styleObject = typeof value2 === "object" ? value2 : parseStyle(String(value2), node2.tagName);
        if (state.stylePropertyNameCase === "css") {
          styleObject = transformStyleToCssCasing(styleObject);
        }
        const cssProperties = [];
        let cssProp;
        for (cssProp in styleObject) {
          if (own9.call(styleObject, cssProp)) {
            cssProperties.push({
              type: "Property",
              method: false,
              shorthand: false,
              computed: false,
              key: name(cssProp) ? { type: "Identifier", name: cssProp } : { type: "Literal", value: cssProp },
              value: { type: "Literal", value: String(styleObject[cssProp]) },
              kind: "init"
            });
          }
        }
        attributeValue = {
          type: "JSXExpressionContainer",
          expression: { type: "ObjectExpression", properties: cssProperties }
        };
      } else if (value2 === true) {
        attributeValue = null;
      } else {
        attributeValue = { type: "Literal", value: String(value2) };
      }
      if (jsxIdentifierName(prop)) {
        attributes.push({
          type: "JSXAttribute",
          name: { type: "JSXIdentifier", name: prop },
          value: attributeValue
        });
      } else {
        attributes.push({
          type: "JSXSpreadAttribute",
          argument: {
            type: "ObjectExpression",
            properties: [
              {
                type: "Property",
                method: false,
                shorthand: false,
                computed: false,
                key: { type: "Literal", value: String(prop) },
                // @ts-expect-error No need to worry about `style` (which has a
                // `JSXExpressionContainer` value) because that’s a valid identifier.
                value: attributeValue || { type: "Literal", value: true },
                kind: "init"
              }
            ]
          }
        });
      }
    }
  }
  state.schema = parentSchema;
  const result = {
    type: "JSXElement",
    openingElement: {
      type: "JSXOpeningElement",
      attributes,
      name: state.createJsxElementName(node2.tagName),
      selfClosing: children.length === 0
    },
    closingElement: children.length > 0 ? {
      type: "JSXClosingElement",
      name: state.createJsxElementName(node2.tagName)
    } : null,
    children
  };
  state.inherit(node2, result);
  return result;
}
function parseStyle(value2, tagName) {
  const result = {};
  try {
    style_to_object_default(value2, iterator);
  } catch (error) {
    const exception = (
      /** @type {Error} */
      error
    );
    exception.message = tagName + "[style]" + exception.message.slice("undefined".length);
    throw error;
  }
  return result;
  function iterator(name2, value3) {
    let key2 = name2;
    if (key2.slice(0, 2) !== "--") {
      if (key2.slice(0, 4) === "-ms-")
        key2 = "ms-" + key2.slice(4);
      key2 = key2.replace(dashSomething, toCamel);
    }
    result[key2] = value3;
  }
}
function transformStyleToCssCasing(domCasing) {
  const cssCasing = {};
  let from;
  for (from in domCasing) {
    if (own9.call(domCasing, from)) {
      let to = from.replace(cap2, toDash);
      if (to.slice(0, 3) === "ms-")
        to = "-" + to;
      cssCasing[to] = domCasing[from];
    }
  }
  return cssCasing;
}
function toCamel(_, $1) {
  return $1.toUpperCase();
}
function toDash($0) {
  return "-" + $0.toLowerCase();
}
function jsxIdentifierName(name2) {
  let index2 = -1;
  while (++index2 < name2.length) {
    if (!(index2 ? cont3 : start2)(name2.charCodeAt(index2)))
      return false;
  }
  return index2 > 0;
  function cont3(code2) {
    return cont2(code2) || code2 === 45;
  }
}

// node_modules/estree-util-attach-comments/lib/index.js
var own10 = {}.hasOwnProperty;
function attachComments(tree, comments) {
  const list3 = (comments || []).concat().sort(compare);
  if (list3.length > 0)
    walk2(tree, { comments: list3, index: 0 });
  return tree;
}
function walk2(node2, state) {
  if (state.index === state.comments.length) {
    return;
  }
  const children = [];
  const comments = [];
  let key2;
  for (key2 in node2) {
    if (own10.call(node2, key2)) {
      const value2 = node2[key2];
      if (value2 && typeof value2 === "object" && key2 !== "comments") {
        if (Array.isArray(value2)) {
          let index3 = -1;
          while (++index3 < value2.length) {
            if (value2[index3] && typeof value2[index3].type === "string") {
              children.push(value2[index3]);
            }
          }
        } else if (typeof value2.type === "string") {
          children.push(value2);
        }
      }
    }
  }
  children.sort(compare);
  comments.push(...slice(state, node2, false, { leading: true, trailing: false }));
  let index2 = -1;
  while (++index2 < children.length) {
    walk2(children[index2], state);
  }
  comments.push(
    ...slice(state, node2, true, {
      leading: false,
      trailing: children.length > 0
    })
  );
  if (comments.length > 0) {
    node2.comments = comments;
  }
}
function slice(state, node2, compareEnd, fields) {
  const result = [];
  while (state.comments[state.index] && compare(state.comments[state.index], node2, compareEnd) < 1) {
    result.push(Object.assign({}, state.comments[state.index++], fields));
  }
  return result;
}
function compare(left, right, compareEnd) {
  const field = compareEnd ? "end" : "start";
  if (left.range && right.range) {
    return left.range[0] - right.range[compareEnd ? 1 : 0];
  }
  if (left.loc && left.loc.start && right.loc && right.loc[field]) {
    return left.loc.start.line - right.loc[field].line || left.loc.start.column - right.loc[field].column;
  }
  if ("start" in left && field in right) {
    return left.start - right[field];
  }
  return Number.NaN;
}

// node_modules/hast-util-to-estree/lib/handlers/mdx-expression.js
function mdxExpression2(node2, state) {
  const estree = node2.data && node2.data.estree;
  const comments = estree && estree.comments || [];
  let expression;
  if (estree) {
    state.comments.push(...comments);
    attachComments(estree, estree.comments);
    expression = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression || void 0;
  }
  if (!expression) {
    expression = { type: "JSXEmptyExpression" };
    state.patch(node2, expression);
  }
  const result = { type: "JSXExpressionContainer", expression };
  state.inherit(node2, result);
  return result;
}

// node_modules/hast-util-to-estree/lib/handlers/mdx-jsx-element.js
function mdxJsxElement(node2, state) {
  const parentSchema = state.schema;
  let schema = parentSchema;
  const attrs = node2.attributes || [];
  let index2 = -1;
  if (node2.name && parentSchema.space === "html" && node2.name.toLowerCase() === "svg") {
    schema = svg2;
    state.schema = schema;
  }
  const children = state.all(node2);
  const attributes = [];
  while (++index2 < attrs.length) {
    const attr = attrs[index2];
    const value2 = attr.value;
    let attributeValue;
    if (attr.type === "mdxJsxAttribute") {
      if (value2 === void 0 || value2 === null) {
        attributeValue = null;
      } else if (typeof value2 === "object") {
        const estree = value2.data && value2.data.estree;
        const comments = estree && estree.comments || [];
        let expression;
        if (estree) {
          state.comments.push(...comments);
          attachComments(estree, estree.comments);
          expression = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression || void 0;
        }
        attributeValue = {
          type: "JSXExpressionContainer",
          expression: expression || { type: "JSXEmptyExpression" }
        };
        state.inherit(value2, attributeValue);
      } else {
        attributeValue = { type: "Literal", value: String(value2) };
      }
      const attribute = {
        type: "JSXAttribute",
        name: state.createJsxAttributeName(attr.name),
        value: attributeValue
      };
      state.inherit(attr, attribute);
      attributes.push(attribute);
    } else {
      const estree = attr.data && attr.data.estree;
      const comments = estree && estree.comments || [];
      let argumentValue;
      if (estree) {
        state.comments.push(...comments);
        attachComments(estree, estree.comments);
        argumentValue = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression && estree.body[0].expression.type === "ObjectExpression" && estree.body[0].expression.properties && estree.body[0].expression.properties[0] && estree.body[0].expression.properties[0].type === "SpreadElement" && estree.body[0].expression.properties[0].argument || void 0;
      }
      const attribute = {
        type: "JSXSpreadAttribute",
        argument: argumentValue || { type: "ObjectExpression", properties: [] }
      };
      state.inherit(attr, attribute);
      attributes.push(attribute);
    }
  }
  state.schema = parentSchema;
  const result = node2.name ? {
    type: "JSXElement",
    openingElement: {
      type: "JSXOpeningElement",
      attributes,
      name: state.createJsxElementName(node2.name),
      selfClosing: children.length === 0
    },
    closingElement: children.length > 0 ? {
      type: "JSXClosingElement",
      name: state.createJsxElementName(node2.name)
    } : null,
    children
  } : {
    type: "JSXFragment",
    openingFragment: { type: "JSXOpeningFragment" },
    closingFragment: { type: "JSXClosingFragment" },
    children
  };
  state.inherit(node2, result);
  return result;
}

// node_modules/hast-util-to-estree/lib/handlers/mdxjs-esm.js
function mdxjsEsm2(node2, state) {
  const estree = node2.data && node2.data.estree;
  const comments = estree && estree.comments || [];
  if (estree) {
    state.comments.push(...comments);
    attachComments(estree, comments);
    state.esm.push(...estree.body);
  }
}

// node_modules/hast-util-to-estree/lib/handlers/text.js
function text4(node2, state) {
  const value2 = String(node2.value || "");
  if (value2) {
    const result = { type: "Literal", value: value2 };
    state.inherit(node2, result);
    const container = { type: "JSXExpressionContainer", expression: result };
    state.patch(node2, container);
    return container;
  }
}

// node_modules/hast-util-whitespace/index.js
function whitespace(thing) {
  const value2 = (
    // @ts-expect-error looks like a node.
    thing && typeof thing === "object" && thing.type === "text" ? (
      // @ts-expect-error looks like a text.
      thing.value || ""
    ) : thing
  );
  return typeof value2 === "string" && value2.replace(/[ \t\n\f\r]/g, "") === "";
}

// node_modules/hast-util-to-estree/lib/handlers/root.js
function root2(node2, state) {
  const children = state.all(node2);
  const cleanChildren = [];
  let index2 = -1;
  let queue;
  while (++index2 < children.length) {
    const child = children[index2];
    if (child.type === "JSXExpressionContainer" && child.expression.type === "Literal" && whitespace(child.expression.value)) {
      if (queue)
        queue.push(child);
    } else {
      if (queue)
        cleanChildren.push(...queue);
      cleanChildren.push(child);
      queue = [];
    }
  }
  const result = {
    type: "JSXFragment",
    openingFragment: { type: "JSXOpeningFragment" },
    closingFragment: { type: "JSXClosingFragment" },
    children: cleanChildren
  };
  state.inherit(node2, result);
  return result;
}

// node_modules/hast-util-to-estree/lib/handlers/index.js
var handlers2 = {
  comment,
  doctype: ignore2,
  element,
  mdxFlowExpression: mdxExpression2,
  mdxTextExpression: mdxExpression2,
  mdxJsxFlowElement: mdxJsxElement,
  mdxJsxTextElement: mdxJsxElement,
  mdxjsEsm: mdxjsEsm2,
  text: text4,
  root: root2
};
function ignore2() {
}

// node_modules/zwitch/index.js
var own11 = {}.hasOwnProperty;
function zwitch(key2, options) {
  const settings = options || {};
  function one3(value2, ...parameters) {
    let fn = one3.invalid;
    const handlers3 = one3.handlers;
    if (value2 && own11.call(value2, key2)) {
      const id = String(value2[key2]);
      fn = own11.call(handlers3, id) ? handlers3[id] : one3.unknown;
    }
    if (fn) {
      return fn.call(this, value2, ...parameters);
    }
  }
  one3.handlers = settings.handlers || {};
  one3.invalid = settings.invalid;
  one3.unknown = settings.unknown;
  return one3;
}

// node_modules/hast-util-to-estree/lib/state.js
var own12 = {}.hasOwnProperty;
var tableElements = /* @__PURE__ */ new Set(["table", "thead", "tbody", "tfoot", "tr"]);
function createState2(options) {
  const one3 = zwitch("type", {
    invalid,
    unknown,
    handlers: { ...handlers2, ...options.handlers }
  });
  return {
    // Current space.
    schema: options.space === "svg" ? svg2 : html3,
    elementAttributeNameCase: options.elementAttributeNameCase || "react",
    stylePropertyNameCase: options.stylePropertyNameCase || "dom",
    // Results.
    comments: [],
    esm: [],
    // Useful functions.
    handle,
    all: all3,
    patch: patch2,
    inherit,
    createJsxAttributeName,
    createJsxElementName
  };
  function handle(node2) {
    return one3(node2, this);
  }
}
function invalid(value2) {
  throw new Error("Cannot handle value `" + value2 + "`, expected node");
}
function unknown(node2) {
  throw new Error("Cannot handle unknown node `" + node2.type + "`");
}
function all3(parent) {
  const children = parent.children || [];
  let index2 = -1;
  const results = [];
  const ignoreLineBreak = this.schema.space === "html" && parent.type === "element" && tableElements.has(parent.tagName.toLowerCase());
  while (++index2 < children.length) {
    const child = children[index2];
    if (ignoreLineBreak && child.type === "text" && child.value === "\n") {
      continue;
    }
    const result = this.handle(child);
    if (Array.isArray(result)) {
      results.push(...result);
    } else if (result) {
      results.push(result);
    }
  }
  return results;
}
function inherit(from, to) {
  const left = from.data;
  let right;
  let key2;
  patch2(from, to);
  if (left) {
    for (key2 in left) {
      if (own12.call(left, key2) && key2 !== "estree") {
        if (!right)
          right = {};
        right[key2] = left[key2];
      }
    }
    if (right) {
      to.data = right;
    }
  }
}
function patch2(from, to) {
  const p = position2(from);
  if (p.start.line && p.start.offset !== void 0 && p.end.offset !== void 0) {
    to.start = p.start.offset;
    to.end = p.end.offset;
    to.loc = {
      start: { line: p.start.line, column: p.start.column - 1 },
      end: { line: p.end.line, column: p.end.column - 1 }
    };
    to.range = [p.start.offset, p.end.offset];
  }
}
function createJsxAttributeName(name2) {
  const node2 = createJsxNameFromString(name2);
  if (node2.type === "JSXMemberExpression") {
    throw new Error("Member expressions in attribute names are not supported");
  }
  return node2;
}
function createJsxElementName(name2) {
  return createJsxNameFromString(name2);
}
function createJsxNameFromString(name2) {
  if (name2.includes(".")) {
    const names = name2.split(".");
    let part = names.shift();
    let node2 = { type: "JSXIdentifier", name: part };
    while (part = names.shift()) {
      node2 = {
        type: "JSXMemberExpression",
        object: node2,
        property: { type: "JSXIdentifier", name: part }
      };
    }
    return node2;
  }
  if (name2.includes(":")) {
    const parts = name2.split(":");
    return {
      type: "JSXNamespacedName",
      namespace: { type: "JSXIdentifier", name: parts[0] },
      name: { type: "JSXIdentifier", name: parts[1] }
    };
  }
  return { type: "JSXIdentifier", name: name2 };
}

// node_modules/hast-util-to-estree/lib/index.js
function toEstree(tree, options) {
  const state = createState2(options || {});
  let result = state.handle(tree);
  const body = state.esm;
  if (result) {
    if (result.type !== "JSXFragment" && result.type !== "JSXElement") {
      result = {
        type: "JSXFragment",
        openingFragment: { type: "JSXOpeningFragment" },
        closingFragment: { type: "JSXClosingFragment" },
        children: [result]
      };
      state.patch(tree, result);
    }
    const statement = { type: "ExpressionStatement", expression: result };
    state.patch(tree, statement);
    body.push(statement);
  }
  const program = {
    type: "Program",
    body,
    sourceType: "module",
    comments: state.comments
  };
  state.patch(tree, program);
  return program;
}

// node_modules/@mdx-js/mdx/lib/plugin/rehype-recma.js
function rehypeRecma(options) {
  return (tree) => toEstree(tree, options);
}

// node_modules/@mdx-js/mdx/lib/plugin/rehype-remove-raw.js
function rehypeRemoveRaw() {
  return (tree) => {
    visit2(tree, "raw", (_, index2, parent) => {
      if (parent && typeof index2 === "number") {
        parent.children.splice(index2, 1);
        return index2;
      }
    });
  };
}

// node_modules/@mdx-js/mdx/lib/plugin/remark-mark-and-unravel.js
function remarkMarkAndUnravel() {
  return (tree) => {
    visit2(tree, (node2, index2, parent) => {
      let offset3 = -1;
      let all4 = true;
      let oneOrMore = false;
      if (parent && typeof index2 === "number" && node2.type === "paragraph") {
        const children = node2.children;
        while (++offset3 < children.length) {
          const child = children[offset3];
          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
            oneOrMore = true;
          } else if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
          } else {
            all4 = false;
            break;
          }
        }
        if (all4 && oneOrMore) {
          offset3 = -1;
          const newChildren = [];
          while (++offset3 < children.length) {
            const child = children[offset3];
            if (child.type === "mdxJsxTextElement") {
              child.type = "mdxJsxFlowElement";
            }
            if (child.type === "mdxTextExpression") {
              child.type = "mdxFlowExpression";
            }
            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
            } else {
              newChildren.push(child);
            }
          }
          parent.children.splice(index2, 1, ...newChildren);
          return index2;
        }
      }
      if (node2.type === "mdxJsxFlowElement" || node2.type === "mdxJsxTextElement") {
        const data3 = node2.data || (node2.data = {});
        data3._mdxExplicitJsx = true;
      }
    });
  };
}

// node_modules/@mdx-js/mdx/lib/node-types.js
var nodeTypes = [
  "mdxFlowExpression",
  "mdxJsxFlowElement",
  "mdxJsxTextElement",
  "mdxTextExpression",
  "mdxjsEsm"
];

// node_modules/@mdx-js/mdx/lib/condition.js
var import_process2 = __toESM(require("process"), 1);
var development = import_process2.default.env.NODE_ENV === "development";

// node_modules/@mdx-js/mdx/lib/core.js
var removedOptions = [
  "filepath",
  "compilers",
  "hastPlugins",
  "mdPlugins",
  "skipExport",
  "wrapExport"
];
function createProcessor(options) {
  const {
    development: development2,
    jsx: jsx2,
    format,
    outputFormat,
    providerImportSource,
    recmaPlugins,
    rehypePlugins,
    remarkPlugins,
    remarkRehypeOptions,
    elementAttributeNameCase,
    stylePropertyNameCase,
    SourceMapGenerator,
    ...rest
  } = options || {};
  const dev = development2 === null || development2 === void 0 ? development : development2;
  let index2 = -1;
  while (++index2 < removedOptions.length) {
    const key2 = removedOptions[index2];
    if (options && key2 in options) {
      throw new Error(
        "`options." + key2 + "` is no longer supported. Please see <https://mdxjs.com/migrating/v2/> for more information"
      );
    }
  }
  if (format === "detect") {
    throw new Error(
      "Incorrect `format: 'detect'`: `createProcessor` can support either `md` or `mdx`; it does not support detecting the format"
    );
  }
  const pipeline = unified().use(remark_parse_default);
  if (format !== "md") {
    pipeline.use(remarkMdx);
  }
  const extraNodeTypes = remarkRehypeOptions ? (
    /* c8 ignore next */
    remarkRehypeOptions.passThrough || []
  ) : [];
  pipeline.use(remarkMarkAndUnravel).use(remarkPlugins || []).use(lib_default, {
    ...remarkRehypeOptions,
    allowDangerousHtml: true,
    passThrough: [...extraNodeTypes, ...nodeTypes]
  }).use(rehypePlugins || []);
  if (format === "md") {
    pipeline.use(rehypeRemoveRaw);
  }
  pipeline.use(rehypeRecma, { elementAttributeNameCase, stylePropertyNameCase }).use(recmaDocument, { ...rest, outputFormat }).use(recmaJsxRewrite, {
    development: dev,
    providerImportSource,
    outputFormat
  });
  if (!jsx2) {
    pipeline.use(recmaJsxBuild, { development: dev, outputFormat });
  }
  pipeline.use(recmaStringify, { SourceMapGenerator }).use(recmaPlugins || []);
  return pipeline;
}

// node_modules/@mdx-js/mdx/lib/util/extnames.js
var import_markdown_extensions = __toESM(require_markdown_extensions2(), 1);
var md = import_markdown_extensions.default.map((d) => "." + d);

// node_modules/@mdx-js/mdx/lib/util/resolve-file-and-options.js
function resolveFileAndOptions(vfileCompatible, options) {
  const file = looksLikeAVFile2(vfileCompatible) ? vfileCompatible : new VFile(vfileCompatible);
  const { format, ...rest } = options || {};
  return {
    file,
    options: {
      format: format === "md" || format === "mdx" ? format : file.extname && (rest.mdExtensions || md).includes(file.extname) ? "md" : "mdx",
      ...rest
    }
  };
}
function looksLikeAVFile2(value2) {
  return Boolean(
    value2 && typeof value2 === "object" && "message" in value2 && "messages" in value2
  );
}

// node_modules/@mdx-js/mdx/lib/compile.js
function compile(vfileCompatible, compileOptions) {
  const { file, options } = resolveFileAndOptions(vfileCompatible, compileOptions);
  return createProcessor(options).process(file);
}
function compileSync(vfileCompatible, compileOptions) {
  const { file, options } = resolveFileAndOptions(vfileCompatible, compileOptions);
  return createProcessor(options).processSync(file);
}

// src/index.ts
var import_generator2 = __toESM(require_lib4());
var t2 = __toESM(require_lib3());
var import_cloneDeep = __toESM(require_cloneDeep2());
var import_estree_to_babel = __toESM(require_estree_to_babel());

// src/sb-mdx-plugin.ts
var t = __toESM(require_lib3());
var import_generator = __toESM(require_lib4());
var import_camelCase = __toESM(require_camelCase());
var import_js_string_escape = __toESM(require_js_string_escape());
var RESERVED = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|await|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/;
function getAttr(elt, what) {
  const attr = elt.attributes.find((n) => n.name.name === what);
  return attr?.value;
}
var isReserved = (name2) => RESERVED.exec(name2);
var startsWithNumber = (name2) => /^\d/.exec(name2);
var sanitizeName = (name2) => {
  let key2 = (0, import_camelCase.default)(name2);
  if (startsWithNumber(key2)) {
    key2 = `_${key2}`;
  } else if (isReserved(key2)) {
    key2 = `${key2}Story`;
  }
  return key2;
};
var getStoryKey = (name2, counter) => name2 ? sanitizeName(name2) : `story${counter}`;
function genAttribute(key2, element2) {
  const value2 = getAttr(element2, key2);
  if (t.isJSXExpressionContainer(value2)) {
    const { code: code2 } = (0, import_generator.default)(value2.expression, {});
    return code2;
  }
  return void 0;
}
function genImportStory(ast, storyDef, storyName, context) {
  const { code: story } = (0, import_generator.default)(storyDef.expression, {});
  const storyKey = `_${story.split(".").pop()}_`;
  const statements = [`export const ${storyKey} = ${story};`];
  if (storyName) {
    context.storyNameToKey[storyName] = storyKey;
    statements.push(`${storyKey}.storyName = '${storyName}';`);
  } else {
    context.storyNameToKey[storyKey] = storyKey;
    ast.openingElement.attributes.push(
      t.jsxAttribute(t.jsxIdentifier("name"), t.stringLiteral(storyKey))
    );
  }
  return {
    [storyKey]: statements.join("\n")
  };
}
function getBodyPart(bodyNode, context) {
  const body = t.isJSXExpressionContainer(bodyNode) ? bodyNode.expression : bodyNode;
  let sourceBody = body;
  if (t.isCallExpression(body) && t.isMemberExpression(body.callee) && t.isIdentifier(body.callee.object) && t.isIdentifier(body.callee.property) && body.callee.property.name === "bind" && (body.arguments.length === 0 || body.arguments.length === 1 && t.isObjectExpression(body.arguments[0]) && body.arguments[0].properties.length === 0)) {
    const bound = body.callee.object.name;
    const namedExport = context.namedExports[bound];
    if (namedExport) {
      sourceBody = namedExport;
    }
  }
  const { code: storyCode } = (0, import_generator.default)(body, {});
  const { code: sourceCode } = (0, import_generator.default)(sourceBody, {});
  return { storyCode, sourceCode, body };
}
var idOrNull = (attr) => t.isStringLiteral(attr) ? attr.value : null;
var expressionOrNull = (attr) => t.isJSXExpressionContainer(attr) ? attr.expression : null;
function genStoryExport(ast, context) {
  if (getAttr(ast.openingElement, "of")) {
    throw new Error(`The 'of' prop is not supported in .stories.mdx files, only .mdx files.
    See https://storybook.js.org/docs/7.0/react/writing-docs/mdx on how to write MDX files and stories separately.`);
  }
  const storyName = idOrNull(getAttr(ast.openingElement, "name"));
  const storyId = idOrNull(getAttr(ast.openingElement, "id"));
  const storyRef = getAttr(ast.openingElement, "story");
  if (!storyId && !storyName && !storyRef) {
    throw new Error("Expected a Story name, id, or story attribute");
  }
  if (storyId) {
    return null;
  }
  if (storyRef) {
    return genImportStory(ast, storyRef, storyName, context);
  }
  const statements = [];
  const storyKey = getStoryKey(storyName, context.counter);
  const bodyNodes = ast.children.filter((n) => !t.isJSXText(n));
  let storyCode = null;
  let sourceCode = null;
  let storyVal = null;
  if (!bodyNodes.length) {
    if (ast.children.length > 0) {
      const { code: code2 } = (0, import_generator.default)(ast.children[0], {});
      storyCode = `'${code2}'`;
      sourceCode = storyCode;
      storyVal = `() => (
        ${storyCode}
      )`;
    } else {
      sourceCode = "{}";
      storyVal = "{}";
    }
  } else {
    const bodyParts = bodyNodes.map((bodyNode) => getBodyPart(bodyNode, context));
    storyCode = bodyParts.map(({ storyCode: code2 }) => code2).join("\n");
    sourceCode = bodyParts.map(({ sourceCode: code2 }) => code2).join("\n");
    const storyReactCode = bodyParts.length > 1 ? `<>
${storyCode}
</>` : storyCode;
    const BIND_REGEX = /\.bind\(.*\)/;
    if (bodyParts.length === 1) {
      if (BIND_REGEX.test(bodyParts[0].storyCode)) {
        storyVal = bodyParts[0].storyCode;
      } else if (t.isIdentifier(bodyParts[0].body)) {
        storyVal = `assertIsFn(${storyCode})`;
      } else if (t.isArrowFunctionExpression(bodyParts[0].body)) {
        storyVal = `(${storyCode})`;
      } else {
        storyVal = `() => (
          ${storyReactCode}
        )`;
      }
    } else {
      storyVal = `() => (
        ${storyReactCode}
      )`;
    }
  }
  statements.push(`export const ${storyKey} = ${storyVal};`);
  statements.push(`${storyKey}.storyName = '${storyName}';`);
  const argTypes = genAttribute("argTypes", ast.openingElement);
  if (argTypes)
    statements.push(`${storyKey}.argTypes = ${argTypes};`);
  const args = genAttribute("args", ast.openingElement);
  if (args)
    statements.push(`${storyKey}.args = ${args};`);
  const parameters = expressionOrNull(getAttr(ast.openingElement, "parameters"));
  const source2 = (0, import_js_string_escape.default)(sourceCode);
  const sourceParam = `storySource: { source: '${source2}' }`;
  if (parameters) {
    const { code: params } = (0, import_generator.default)(parameters, {});
    statements.push(`${storyKey}.parameters = { ${sourceParam}, ...${params} };`);
  } else {
    statements.push(`${storyKey}.parameters = { ${sourceParam} };`);
  }
  const decorators = expressionOrNull(getAttr(ast.openingElement, "decorators"));
  if (decorators) {
    const { code: decos } = (0, import_generator.default)(decorators, {});
    statements.push(`${storyKey}.decorators = ${decos};`);
  }
  const loaders = expressionOrNull(getAttr(ast.openingElement, "loaders"));
  if (loaders) {
    const { code: loaderCode } = (0, import_generator.default)(loaders, {});
    statements.push(`${storyKey}.loaders = ${loaderCode};`);
  }
  const play = expressionOrNull(getAttr(ast.openingElement, "play"));
  if (play) {
    const { code: playCode } = (0, import_generator.default)(play, {});
    statements.push(`${storyKey}.play = ${playCode};`);
  }
  const render = expressionOrNull(getAttr(ast.openingElement, "render"));
  if (render) {
    const { code: renderCode } = (0, import_generator.default)(render, {});
    statements.push(`${storyKey}.render = ${renderCode};`);
  }
  context.storyNameToKey[storyName] = storyKey;
  return {
    [storyKey]: statements.join("\n")
  };
}
function genCanvasExports(ast, context) {
  const canvasExports = {};
  for (let i = 0; i < ast.children.length; i += 1) {
    const child = ast.children[i];
    if (t.isJSXElement(child) && t.isJSXIdentifier(child.openingElement.name) && child.openingElement.name.name === "Story") {
      const storyExport = genStoryExport(child, context);
      const { code: code2 } = (0, import_generator.default)(child, {});
      child.value = code2;
      if (storyExport) {
        Object.assign(canvasExports, storyExport);
        context.counter += 1;
      }
    }
  }
  return canvasExports;
}
function genMeta(ast, options) {
  if (getAttr(ast.openingElement, "of")) {
    throw new Error(`The 'of' prop is not supported in .stories.mdx files, only .mdx files.
    See https://storybook.js.org/docs/7.0/react/writing-docs/mdx on how to write MDX files and stories separately.`);
  }
  const titleAttr = getAttr(ast.openingElement, "title");
  const idAttr = getAttr(ast.openingElement, "id");
  let title = null;
  if (titleAttr) {
    if (t.isStringLiteral(titleAttr)) {
      title = "'".concat((0, import_js_string_escape.default)(titleAttr.value), "'");
    } else if (t.isJSXExpressionContainer(titleAttr)) {
      try {
        const { code: code2 } = (0, import_generator.default)(titleAttr.expression, {});
        title = code2.replace(/^\{(.+)\}$/, "$1");
      } catch (e) {
        console.warn("Invalid title:", options.filepath);
        title = void 0;
      }
    } else {
      console.warn(`Unknown title attr: ${titleAttr.type}`);
    }
  }
  const id = t.isStringLiteral(idAttr) ? `'${idAttr.value}'` : null;
  const parameters = genAttribute("parameters", ast.openingElement);
  const decorators = genAttribute("decorators", ast.openingElement);
  const loaders = genAttribute("loaders", ast.openingElement);
  const component = genAttribute("component", ast.openingElement);
  const subcomponents = genAttribute("subcomponents", ast.openingElement);
  const args = genAttribute("args", ast.openingElement);
  const argTypes = genAttribute("argTypes", ast.openingElement);
  const render = genAttribute("render", ast.openingElement);
  return {
    title,
    id,
    parameters,
    decorators,
    loaders,
    component,
    subcomponents,
    args,
    argTypes,
    render,
    tags: "['stories-mdx']"
  };
}
var wrapperJs = `
componentMeta.parameters = componentMeta.parameters || {};
componentMeta.parameters.docs = {
  ...(componentMeta.parameters.docs || {}),
  page: MDXContent,
};
`.trim();
function stringifyMeta(meta) {
  let result = "{ ";
  Object.entries(meta).forEach(([key2, val]) => {
    if (val) {
      result += `${key2}: ${val}, `;
    }
  });
  result += " }";
  return result;
}

// src/jsx.ts
var import_core3 = __toESM(require_lib32());
var import_preset_react = __toESM(require_lib37());
function getBabelOptions(jsxOptions) {
  return {
    filename: "file.js",
    sourceType: "module",
    configFile: false,
    babelrc: false,
    presets: [
      [
        import_preset_react.default,
        {
          runtime: "automatic",
          ...jsxOptions
        }
      ]
    ]
  };
}
var transformJSXAsync = async (input, jsxOptions) => {
  const babelOptions = getBabelOptions(jsxOptions);
  const { code: code2 } = await (0, import_core3.transformAsync)(input, babelOptions);
  return code2;
};
var transformJSXSync = (input, jsxOptions) => {
  const babelOptions = getBabelOptions(jsxOptions);
  const { code: code2 } = (0, import_core3.transformSync)(input, babelOptions);
  return code2;
};

// src/index.ts
var SEPARATOR = "/* ========= */";
var hasStoryChild = (node2) => {
  return node2.children?.length > 0 && node2.children.find((c2) => c2.name === "Story");
};
var generateMdxSource = (canvas) => {
  const babel = (0, import_estree_to_babel.default)((0, import_cloneDeep.default)(toEstree(canvas)));
  const { code: code2 } = (0, import_generator2.default)(babel, {});
  return code2.replace(/<\/?Canvas[^>]*>;?/g, "");
};
function extractExports(root4, options) {
  const context = {
    counter: 0,
    storyNameToKey: {},
    namedExports: {}
  };
  const storyExports = [];
  const includeStories = [];
  let metaExport = null;
  let contents;
  root4.program.body.forEach((child) => {
    if (t2.isExpressionStatement(child) && t2.isJSXFragment(child.expression)) {
      if (contents)
        throw new Error("duplicate contents");
      contents = child;
    } else if (t2.isExportNamedDeclaration(child) && t2.isVariableDeclaration(child.declaration) && child.declaration.declarations.length === 1) {
      const declaration = child.declaration.declarations[0];
      if (t2.isVariableDeclarator(declaration) && t2.isIdentifier(declaration.id)) {
        const { name: name2 } = declaration.id;
        context.namedExports[name2] = declaration.init;
      }
    }
  });
  if (contents) {
    const jsx2 = contents.expression;
    jsx2.children.forEach((child) => {
      if (t2.isJSXElement(child)) {
        if (t2.isJSXIdentifier(child.openingElement.name)) {
          const name2 = child.openingElement.name.name;
          let stories;
          if (["Canvas", "Preview"].includes(name2)) {
            stories = genCanvasExports(child, context);
          } else if (name2 === "Story") {
            stories = genStoryExport(child, context);
          } else if (name2 === "Meta") {
            const meta = genMeta(child, options);
            if (meta) {
              if (metaExport) {
                throw new Error("Meta can only be declared once");
              }
              metaExport = meta;
            }
          }
          if (stories) {
            Object.entries(stories).forEach(([key2, story]) => {
              includeStories.push(key2);
              storyExports.push(story);
            });
          }
        }
      } else if (t2.isJSXExpressionContainer(child)) {
      } else {
        throw new Error(`Unexpected JSX child: ${child.type}`);
      }
    });
  }
  if (metaExport) {
    if (!storyExports.length) {
      storyExports.push('export const __page = () => { throw new Error("Docs-only story"); };');
      storyExports.push("__page.parameters = { docsOnly: true };");
      includeStories.push("__page");
    }
  } else {
    metaExport = {};
  }
  metaExport.includeStories = JSON.stringify(includeStories);
  const fullJsx = [
    ...storyExports,
    `const componentMeta = ${stringifyMeta(metaExport)};`,
    wrapperJs,
    "export default componentMeta;"
  ].join("\n\n");
  return fullJsx;
}
var genBabel = (store, root4) => {
  const estree = store.toEstree(root4);
  const clone = (0, import_cloneDeep.default)(estree);
  const babel = (0, import_estree_to_babel.default)(clone);
  return babel;
};
var plugin = (store) => (root4) => {
  const babel = genBabel(store, root4);
  store.exports = extractExports(babel, {});
  root4.children.forEach((node2) => {
    if (node2.type === "mdxJsxFlowElement" && node2.name === "Canvas") {
      if (!hasStoryChild(node2)) {
        node2.attributes = [
          ...node2.attributes || [],
          { type: "mdxJsxAttribute", name: "mdxSource", value: generateMdxSource(node2) }
        ];
      }
    }
  });
  return root4;
};
var postprocess2 = (code2, extractedExports) => {
  const lines = code2.toString().trim().split("\n");
  const first = lines.shift();
  return [
    ...lines.filter((line2) => !line2.match(/^export default/)),
    SEPARATOR,
    extractedExports
  ].join("\n");
};
var compile2 = async (input, { skipCsf = false, mdxCompileOptions = {}, jsxOptions = {} } = {}) => {
  const { options, context } = getCompilerOptionsAndContext(mdxCompileOptions, skipCsf);
  if (skipCsf) {
    const mdxResult2 = await compile(input, options);
    return mdxResult2.toString();
  }
  const mdxResult = await compile(input, options);
  return transformJSXAsync(postprocess2(mdxResult.toString(), context.exports), jsxOptions);
};
var compileSync2 = (input, { skipCsf = false, mdxCompileOptions = {}, jsxOptions = {} } = {}) => {
  const { options, context } = getCompilerOptionsAndContext(mdxCompileOptions, skipCsf);
  if (skipCsf) {
    const mdxResult2 = compileSync(input, options);
    return mdxResult2.toString();
  }
  const mdxResult = compileSync(input, options);
  return transformJSXSync(postprocess2(mdxResult.toString(), context.exports), jsxOptions);
};
function getCompilerOptionsAndContext(mdxCompileOptions, skipCsf = false) {
  if (skipCsf) {
    return {
      options: {
        providerImportSource: "@mdx-js/react",
        rehypePlugins: [],
        ...mdxCompileOptions
      },
      context: {}
    };
  }
  const context = { exports: "", toEstree };
  return {
    options: {
      providerImportSource: "@mdx-js/react",
      ...mdxCompileOptions,
      rehypePlugins: [...mdxCompileOptions?.rehypePlugins || [], [plugin, context]],
      // preserve the JSX, we'll deal with it using babel
      jsx: true
    },
    context
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  SEPARATOR,
  compile,
  compileSync,
  genBabel,
  plugin,
  postprocess,
  wrapperJs
});
/*! Bundled license information:

is-buffer/index.js:
  (*!
   * Determine if an object is a Buffer
   *
   * @author   Feross Aboukhadijeh <https://feross.org>
   * @license  MIT
   *)
*/